home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / phigs / ptk.lha / ptk / source / library / wind.c < prev   
Encoding:
C/C++ Source or Header  |  1992-10-01  |  148.0 KB  |  4,960 lines
  1. /*----------------------------------------------------------------------------
  2.  
  3.   Module name: PHIGS windows.
  4.  
  5.   Author: Gareth Williams.
  6.  
  7.   Function: This module contains functions for displaying PHIGS structures
  8.             in windows.
  9.  
  10.   Dependencies:
  11.  
  12.   Internal function list: 
  13.  
  14.   External function list: 
  15.  
  16.   Hashtables used: "structureid", "name", "label", "viewindex".
  17.  
  18.   Modification history: (Version), (Date), (name), (Description).
  19.  
  20.   1.0, 5th September 1991, G. Williams, First version.
  21.  
  22.   2.0, June 1992, G. Williams, Converted to ISO PHIGS C.
  23.  
  24. ----------------------------------------------------------------------------*/
  25.  
  26. #include <stdio.h>
  27. #include <math.h>
  28. #include <varargs.h>
  29. #ifdef SUN
  30. #include <string.h>
  31. #include <strings.h> 
  32. #endif
  33. #ifdef PEXSI
  34. #include <string.h>
  35. #include <strings.h> 
  36. #endif
  37. #include <phigs.h>
  38. #include "ptk.h"
  39.  
  40. /* constants */
  41.  
  42. #define PI      3.14159
  43.  
  44. /* data types */
  45.  
  46. #define ptkctmlinespace    0.008
  47.  
  48. #define ptkcfloatformat        20
  49.  
  50. typedef struct ptksterminal 
  51. {
  52.   Pint textstid;
  53.   Pint lines, columns, curr_colm, curr_line;
  54.   Pint visline;
  55.   Pfloat increment;
  56.   char floatformat[ptkcfloatformat];
  57.   char *lastline;
  58.   Pfloat realcols, reallines;
  59.   Pint txfont, txcolour;
  60. } ptksterminal;
  61.  
  62. typedef struct ptkswindow
  63. {
  64.   /* window variables */
  65.   Pint windowid;
  66.   Pint windowstid;
  67.   ptkewindowtype windowtype;
  68.   ptkewindowstate windowstate;
  69.   Pint iconstid;
  70.   Pint wsid;
  71.   Pint currentstid;
  72.   Pint windowname;
  73.   ptkboolean posted;
  74.   Pvisual_st viewstate;
  75.  
  76.   Pint windowviewind;
  77.   Ppoint windowsize;
  78.   Ppoint windowposition;
  79.   Ppoint iconsize;
  80.   Ppoint iconposition;
  81.   Ppoint framesize;
  82.   Pint usericon;
  83.   ptkboolean defaulticon;
  84.   Pint backgdcolour, edgecolour, frametlcolour, framebrcolour, bannercolour;
  85.   char titlestring[50];
  86.   Pfloat bannerheight;
  87.   Pint titlefont, titlecolour;
  88.  
  89.   Plimit3 viewlims, viewbox;
  90.   Ppoint3 viewvolume;
  91.   ptkecamerastate cameraswitch;
  92.  
  93.   /* camera variables */
  94.   Pfloat swivelangle, twistangle, spinangle;
  95.   Ppoint3 position; /* prp */
  96.   Ppoint3 ptinterest; /* vrp */
  97.   Ppoint3 positionaxis;
  98.   Ppoint3 ptinterestaxis;
  99.   Ppoint3 lastvpn, lastvup;
  100.   Pproj_type cameraproj;
  101.   Ppoint3 xaxis, yaxis;
  102.  
  103.   /* viewing variables */
  104.   Ppoint3 vrp, proj_ref_point;
  105.   Ppoint3 vpn, vup;
  106.   Plimit win;
  107.   Plimit3 proj_vp;
  108.   Pproj_type proj_type;
  109.   Pfloat viewplane, backplane, frontplane;
  110.   Pclip_ind clipxy, clipfront, clipback;
  111.   Plimit3 cliplimit;
  112.  
  113.   /* terminal window variables */
  114.   ptksterminal term;
  115.  
  116.   /* topology view area */
  117.   Plimit topviewarea;
  118.  
  119.   /* content window variables */
  120.   Pint range1, range2;
  121.   Pint viewrange1, viewrange2;
  122.  
  123.   /* next window */
  124.   struct ptkswindow *next;
  125. } ptkswindow;
  126.  
  127. typedef struct 
  128. {
  129.   ptkboolean postedwindows;
  130.   ptkswindow *frontptr;
  131.   ptkswindow *backptr;
  132. } ptkswswindow;
  133.  
  134. /*--------------------------------------------------------------------------*/
  135.  
  136. /* PHIGS viewing variables */
  137. static Ppoint3  vrp;
  138. static Ppoint3 vpn, vup;
  139. static Pview_map3 vmap;
  140.  
  141. static ptkswindow *windptr = NULL;
  142. static ptkswindow *firstwind = NULL;
  143. static ptkswindow *lastwind = NULL;
  144.  
  145. static Pint numwsids = 0;
  146. static Pint wsids[10];
  147. static ptkswswindow wswindows[10];
  148. static Pint windowcount = 0;
  149.  
  150. static Ppoint3 origin = {0.0, 0.0, 0.0};
  151.  
  152. /*--------------------------------------------------------------------------*/
  153.  
  154. static void setwindow(C(Pint) windid)
  155. PreANSI(Pint windid)
  156. {
  157.   ptkswindow *ptr;
  158.  
  159.   if (firstwind == NULL)
  160.   {
  161.     windptr = NULL;
  162.     return;
  163.   }
  164.   ptr = firstwind;
  165.   while (ptr->windowid != windid)
  166.   {
  167.     ptr = ptr->next;
  168.     if (ptr == NULL)
  169.     {
  170.       windptr = NULL;
  171.       return;
  172.     }
  173.   }
  174.   windptr = ptr;
  175. }  /* setwindow */
  176.  
  177. /*-------------------------------------------------------------------------*/
  178.  
  179. static ptkboolean getwindowid(C(Pint) windowstid, C(Pint *) windowid)
  180. PreANSI(Pint windowstid)
  181. PreANSI(Pint *windowid)
  182. {
  183.   ptkswindow *ptr;
  184.  
  185.   ptr = firstwind;
  186.   while (ptr->windowstid != windowstid)
  187.   {
  188.     ptr = ptr->next;
  189.     if (ptr == NULL)
  190.       return FALSE;
  191.   }
  192.   *windowid = ptr->windowid;
  193.   return TRUE;
  194. }  /* getwindowid */
  195.  
  196. /*--------------------------------------------------------------------------*/
  197.  
  198. static void findwsid(C(Pint) wsid, C(Pint *) ind)
  199. PreANSI(Pint wsid)
  200. PreANSI(Pint *ind)
  201. {
  202.   Pint i;
  203.  
  204.   *ind = -1;
  205.   for (i = 0; i < numwsids; i++)
  206.     if (wsids[i] == wsid)
  207.       *ind = i;
  208. }  /* findwsid */
  209.  
  210. /*--------------------------------------------------------------------------*/
  211.  
  212. static void checkws(C(Pint) wsid)
  213. PreANSI(Pint wsid)
  214. {
  215.   Pint ind;
  216.  
  217.   findwsid(wsid, &ind);
  218.   if (ind == -1)
  219.   {
  220.     wsids[numwsids] = wsid;
  221.     wswindows[numwsids].postedwindows = FALSE;
  222.     wswindows[numwsids].frontptr = NULL;
  223.     wswindows[numwsids].backptr = NULL;
  224.     numwsids++;
  225.   }
  226. }  /* checkws */
  227.  
  228. /*--------------------------------------------------------------------------*/
  229.  
  230. static ptkboolean iswindow(C(Pint) windstid, C(ptkswindow **) wptr)
  231. PreANSI(Pint windstid)
  232. PreANSI(ptkswindow **wptr)
  233. {
  234.   ptkswindow *ptr;
  235.   ptkboolean found;
  236.  
  237.   ptr = firstwind;
  238.   found = FALSE;
  239.   while ((ptr != NULL) && (!found))
  240.   {
  241.     if (ptr->currentstid == windstid)
  242.     {
  243.       *wptr = ptr;
  244.       found = TRUE;
  245.     }
  246.     else
  247.       ptr = ptr->next;
  248.   }
  249.   return found;
  250. }  /* iswindow */
  251.  
  252. /*--------------------------------------------------------------------------*/
  253.  
  254. static void findfront(C(Pint) wsid, C(ptkswswindow *) wsfront)
  255. PreANSI(Pint wsid)
  256. PreANSI(ptkswswindow *wsfront)
  257. {
  258.   Pposted_struct_list structlist;
  259.   Pint numstructs, error, i;
  260.   Pfloat priority;
  261.   ptkboolean found;
  262.   ptkswindow *wptr;
  263.  
  264.   found = FALSE;
  265.   priority = 0.0;
  266.   i = 0;
  267.   pinq_posted_structs(wsid, 0, 0, &error, &structlist, &numstructs);
  268.   structlist.postings = (Pposted_struct *)calloc(numstructs, 
  269.                                               sizeof(Pposted_struct));
  270.   pinq_posted_structs(wsid, numstructs, 0, &error, &structlist, &numstructs);
  271.   for (i = 0; i < numstructs; i++) 
  272.   {
  273.     /* find highest priority window structure */
  274.     if (iswindow(structlist.postings[i].id, &wptr))
  275.       if (structlist.postings[i].disp_pri > priority)
  276.       {
  277.         priority = structlist.postings[i].disp_pri;
  278.         wsfront->frontptr = wptr;
  279.         found = TRUE;
  280.       }
  281.   }
  282.   if (!found)
  283.     wsfront->postedwindows = FALSE;
  284. }  /* findfront */
  285.  
  286. /*--------------------------------------------------------------------------*/
  287.  
  288. static void findback(C(Pint) wsid, C(ptkswswindow *) wsback)
  289. PreANSI(Pint wsid)
  290. PreANSI(ptkswswindow *wsback)
  291. {
  292.   Pposted_struct_list structlist;
  293.   Pint numstructs, error, i;
  294.   Pfloat priority;
  295.   ptkboolean found;
  296.   ptkswindow *wptr;
  297.  
  298.   priority = 1.0;
  299.   pinq_posted_structs(wsid, 0, 0, &error, &structlist, &numstructs);
  300.   structlist.postings = (Pposted_struct *)calloc(numstructs, 
  301.                                               sizeof(Pposted_struct));
  302.   pinq_posted_structs(wsid, numstructs, 0, &error, &structlist, &numstructs);
  303.   for (i = 0; i < numstructs; i++) 
  304.   {
  305.     /* find lowest priority window structure */
  306.     if (iswindow(structlist.postings[i].id, &wptr))
  307.       if (structlist.postings[i].disp_pri < priority)
  308.       {
  309.         priority = structlist.postings[i].disp_pri;
  310.         wsback->backptr = wptr;
  311.         found = TRUE;
  312.       }
  313.   }
  314.   if (!found)
  315.     wsback->postedwindows = FALSE;
  316. }  /* findback */
  317.  
  318. /*--------------------------------------------------------------------------*/
  319.  
  320. static void setvalidwindowpos()
  321. {
  322.   Plimit lim;
  323.  
  324.   lim = ptk_limit(windptr->windowposition.x - (windptr->windowsize.x / 2.0), 
  325.                   windptr->windowposition.x + (windptr->windowsize.x / 2.0),
  326.                   windptr->windowposition.y - (windptr->windowsize.y / 2.0), 
  327.                   windptr->windowposition.y + (windptr->windowsize.y / 2.0) + 
  328.                   windptr->bannerheight);
  329.   if ((lim.x_min < 0.0) && (lim.y_min < 0.0))
  330.   {
  331.     /* bottom left */
  332.     windptr->windowposition.x += PTKMIN(1.0 - lim.x_max, -lim.x_min);
  333.     windptr->windowposition.y += PTKMIN(1.0 - lim.y_max, -lim.y_min);
  334.   }
  335.   else
  336.   if ((lim.x_min < 0.0) && (lim.y_max > 1.0))
  337.   {
  338.     /* top left */
  339.     windptr->windowposition.x += PTKMIN(1.0 - lim.x_max, -lim.x_min);
  340.     windptr->windowposition.y -= PTKMIN(lim.y_min, lim.y_max - 1.0);
  341.   }
  342.   else
  343.   if ((lim.x_max > 1.0) && (lim.y_min < 0.0))
  344.   {
  345.     /* bottom right */
  346.     windptr->windowposition.x -= PTKMIN(lim.x_min, lim.x_max - 1.0);
  347.     windptr->windowposition.y += PTKMIN(1.0 - lim.y_max, -lim.y_min);
  348.   }
  349.   else
  350.   if ((lim.x_max > 1.0) && (lim.y_max > 1.0))
  351.   {
  352.     /* top right */
  353.     windptr->windowposition.x -= PTKMIN(lim.x_min, lim.x_max - 1.0);
  354.     windptr->windowposition.y -= PTKMIN(lim.y_min, lim.y_max - 1.0);
  355.   }
  356.   else 
  357.   if (lim.x_min < 0.0)
  358.     windptr->windowposition.x += PTKMIN(1.0 - lim.x_max, -lim.x_min);
  359.   else
  360.   if (lim.x_max > 1.0)
  361.     windptr->windowposition.x -= PTKMIN(lim.x_min, lim.x_max - 1.0);
  362.   else
  363.   if (lim.y_min < 0.0)
  364.     windptr->windowposition.y += PTKMIN(1.0 - lim.y_max, -lim.y_min);
  365.   else
  366.   if (lim.y_max > 1.0)
  367.     windptr->windowposition.y -= PTKMIN(lim.y_min, lim.y_max - 1.0);
  368. }  /* setvalidwindowpos */
  369.  
  370. /*--------------------------------------------------------------------------*/
  371.  
  372. static void setvalidwindowsize()
  373. {
  374.   Plimit lim;
  375.  
  376.   lim = ptk_limit(windptr->windowposition.x - (windptr->windowsize.x / 2.0), 
  377.                   windptr->windowposition.x + (windptr->windowsize.x / 2.0),
  378.                   windptr->windowposition.y - (windptr->windowsize.y / 2.0), 
  379.                   windptr->windowposition.y + (windptr->windowsize.y / 2.0));
  380.   if (lim.x_min < 0.0)
  381.     lim.x_min = 0.0;
  382.   if (lim.x_max > 1.0)
  383.     lim.x_max = 1.0;
  384.   if (lim.y_min < 0.0)
  385.     lim.y_min = 0.0;
  386.   if (lim.y_max + windptr->bannerheight > 1.0)
  387.     lim.y_max = 1.0 - windptr->bannerheight;
  388.   windptr->windowposition = ptk_point(lim.x_min + (lim.x_max - lim.x_min) / 2.0,
  389.                                       lim.y_min + (lim.y_max - lim.y_min) / 2.0);
  390.   windptr->windowsize = ptk_point(lim.x_max - lim.x_min, lim.y_max - lim.y_min);
  391. }  /* setvalidwindowsize */
  392.  
  393. /*--------------------------------------------------------------------------*/
  394.  
  395. static void maxadjustlimits(C(Ppoint3 *) boundvolume)
  396. PreANSI(Ppoint3 *boundvolume)
  397. {
  398.   Pfloat  projht, projwt, aspectratio, maxdimen;
  399.  
  400.   /* calculate aspect ratio of window */
  401.   projht = windptr->viewlims.y_max - windptr->viewlims.y_min;
  402.   projwt = windptr->viewlims.x_max - windptr->viewlims.x_min;
  403.   aspectratio = PTKMAX(projht, projwt) / PTKMIN(projht, projwt);
  404.  
  405.   /* adjust view volume to have same aspect ratio as window */
  406.   maxdimen = PTKMAX(boundvolume->x, PTKMAX(boundvolume->y, boundvolume->z));
  407.   windptr->viewvolume = ptk_point3(maxdimen, maxdimen, maxdimen);
  408.  
  409.   if (projht == projwt)
  410.   {
  411.     if (maxdimen > boundvolume->y)
  412.       windptr->viewvolume.y *= aspectratio;
  413.     if (maxdimen > boundvolume->x)
  414.       windptr->viewvolume.x *= aspectratio;
  415.     if (maxdimen > boundvolume->z)
  416.       windptr->viewvolume.z *= aspectratio;
  417.   }
  418.   else
  419.   if (projht > projwt)
  420.     windptr->viewvolume.y *= aspectratio;
  421.   else
  422.   if (projht < projwt)
  423.     windptr->viewvolume.x *= aspectratio;
  424.  
  425.   /*
  426.   ** calculate zmax so that projection viewport has same
  427.   ** aspect ratio as view volume.
  428.   */
  429.  
  430.   windptr->viewlims.z_max = windptr->viewvolume.z * 
  431.                        (projht / windptr->viewvolume.y);
  432. }  /* maxadjustlimits */
  433.  
  434. /*--------------------------------------------------------------------------*/
  435.  
  436. static void adjustlimits(C(Ppoint3 *) viewvolume)
  437. PreANSI(Ppoint3 *viewvolume)
  438. {
  439.   Pfloat projht, projwt, winwt, winht, aspectratio, winaspectratio;
  440.   Pfloat diff, height;
  441.  
  442.   /* adjust view volume to have same aspect ratio as window */
  443.  
  444.   /* calculate aspect ratio of view area */
  445.   if ((viewvolume->y == 0.0) || (viewvolume->x == 0.0))
  446.     aspectratio = 1.0;
  447.   else
  448.     aspectratio = viewvolume->y / viewvolume->x;
  449.  
  450.   /* adjust projection viewport to have same aspect ratio as view volume */
  451.   windptr->viewbox = windptr->viewlims;
  452.   winht = windptr->viewbox.y_max - windptr->viewbox.y_min;
  453.   winwt = windptr->viewbox.x_max - windptr->viewbox.x_min;
  454.   if ((winht == 0.0) || (winwt == 0.0))
  455.     winaspectratio = 1.0;
  456.   else
  457.     winaspectratio = winht / winwt;    
  458.   if (aspectratio > winaspectratio)
  459.   {
  460.     /* decrease x */
  461.     diff = (winwt - ((1.0 / aspectratio) * winht));
  462.     windptr->viewbox.x_max -= diff / 2.0;
  463.     windptr->viewbox.x_min += diff / 2.0;
  464.   }
  465.   else
  466.   if (aspectratio < winaspectratio)
  467.   {
  468.     /* decrease y */
  469.     diff = (winht - (aspectratio * winwt));
  470.     windptr->viewbox.y_min += diff / 2.0;
  471.     windptr->viewbox.y_max -= diff / 2.0;
  472.   }       
  473.  
  474.   /*
  475.   ** calculate zmax so that projection viewport has same
  476.   ** aspect ratio as view volume.
  477.   */
  478.   height = windptr->viewbox.y_max - windptr->viewbox.y_min;
  479.   
  480.   if ((height == 0.0) || (viewvolume->y == 0.0))
  481.     windptr->viewbox.z_max = 1.0;
  482.   else
  483.     windptr->viewbox.z_max = PTKMIN(height, viewvolume->y) / 
  484.                           PTKMAX(height, viewvolume->y);
  485. }  /* adjustlimits */
  486.  
  487. /*--------------------------------------------------------------------------*/
  488.  
  489. static void evalviewvolume(C(Plimit3 *) wclimits, C(ptkboolean) docube)
  490. PreANSI(Plimit3 *wclimits)
  491. PreANSI(ptkboolean docube)
  492. {
  493.   Ppoint3 boundvolume, minbox, maxbox, centrebox, ptinterest, scale;
  494.   Pmatrix3 mat;
  495.   Ppoint3 pmin, pmax;
  496.   Pfloat diameter;
  497.  
  498.   minbox = ptk_point3(wclimits->x_min, wclimits->y_min, wclimits->z_min);
  499.   maxbox = ptk_point3(wclimits->x_max, wclimits->y_max, wclimits->z_max);
  500.  
  501.   /* find centre of limits */
  502.   centrebox = ptk_subv3(&maxbox, &minbox);
  503.   ptinterest = ptk_scalev3(¢rebox, 0.5);
  504.   ptinterest = ptk_addv3(&ptinterest, &minbox);
  505.   windptr->ptinterest = windptr->position = ptinterest;
  506.   centrebox = ptk_scalev3(&ptinterest, -0.5);
  507.   ptk_shift3(¢rebox, PTYPE_REPLACE, mat);
  508.  
  509.   if (docube)
  510.   {
  511.     /* increase box by 10 percent in all directions */
  512.     scale = ptk_point3(1.1, 1.1, 1.1);
  513.     ptk_scale3(&scale, PTYPE_POSTCONCAT, mat);
  514.   }
  515.  
  516.   centrebox = ptk_scalev3(¢rebox, -1.0);
  517.   ptk_shift3(¢rebox, PTYPE_POSTCONCAT, mat);        
  518.   minbox = ptk_transform3(mat, &minbox);
  519.   maxbox = ptk_transform3(mat, &maxbox); 
  520.  
  521.   /* bound volume is width, height and depth of limits */
  522.   boundvolume = ptk_subv3(&maxbox, &minbox);
  523.  
  524.   if (docube)
  525.   {
  526.     diameter = sqrt((boundvolume.x * boundvolume.x) +
  527.                     (boundvolume.y * boundvolume.y) +
  528.                     (boundvolume.z * boundvolume.z));
  529.     windptr->viewvolume = ptk_point3(diameter, diameter, diameter);
  530.   }
  531.   else
  532.     windptr->viewvolume = boundvolume;
  533.   adjustlimits(&windptr->viewvolume);
  534.   windptr->position.z += windptr->viewvolume.z;
  535. }  /* evalviewvolume */
  536.  
  537. /*--------------------------------------------------------------------------*/
  538.  
  539. static evalviewport(C(Plimit3 *) outview)
  540. PreANSI(Plimit3 *outview)
  541. {
  542.   Pfloat unitcube;
  543.   Ppoint origin;
  544.  
  545.   unitcube = PTKMIN(windptr->windowsize.x, windptr->windowsize.y);
  546.   outview->x_min *= unitcube;
  547.   outview->x_max *= unitcube;
  548.   outview->y_min *= unitcube;
  549.   outview->y_max *= unitcube;
  550.   outview->z_min *= unitcube;
  551.   outview->z_max *= unitcube;
  552.   origin = windptr->windowposition;
  553.   origin.x -= unitcube / 2.0;
  554.   origin.y -= unitcube / 2.0;
  555.   outview->x_min += origin.x;
  556.   outview->x_max += origin.x;
  557.   outview->y_min += origin.y;
  558.   outview->y_max += origin.y;
  559. }  /* evalviewport */
  560.  
  561. /*--------------------------------------------------------------------------*/
  562.  
  563. static void buildframe()
  564. /* build frame about the origin according to window size
  565. ** and frame size.
  566. */
  567. {
  568.   Ppoint3 pts[6], centre;
  569.   Ppoint centresize, bannercentre, bannerbox, framesize;
  570.   Pfloat charheight;
  571.   Ptext_align txalign;
  572.   Ppoint_list3 sets, ptlist;
  573.  
  574.   centre = ptk_point3(0.0, windptr->bannerheight / 2.0, 0.0);
  575.   centresize = windptr->windowsize;
  576.   centresize.y += windptr->bannerheight;
  577.   framesize = windptr->framesize;
  578.  
  579.   pts[0] = ptk_point3(centre.x - (centresize.x / 2.0) - framesize.x, 
  580.                       centre.y - (centresize.y / 2.0) - framesize.y,
  581.                       centre.z);
  582.   pts[1] = ptk_point3(pts[0].x, pts[0].y + centresize.y + (2.0 * framesize.y),
  583.                       centre.z);
  584.   pts[2] = ptk_point3(pts[0].x + centresize.x + (2.0 * framesize.x), pts[1].y,
  585.                       centre.z);
  586.   pts[3] = ptk_point3(pts[2].x - framesize.x, 
  587.                       pts[2].y - framesize.y, centre.z);
  588.   pts[4] = ptk_point3(pts[1].x + framesize.x, pts[3].y, 
  589.                       centre.z);
  590.   pts[5] = ptk_point3(pts[4].x, pts[0].y + framesize.y, 
  591.                       centre.z);
  592.   /* frame */
  593.   pset_pick_id(PTKEWINDOWFRAME);
  594.   pset_int_style(PSTYLE_SOLID);
  595.   pset_int_colr_ind(windptr->frametlcolour);
  596.   pts[2] = ptk_point3(pts[0].x + centresize.x + (2.0 * framesize.x), 
  597.                       pts[1].y, centre.z);
  598.   ptlist.num_points = 6;
  599.   ptlist.points = pts;
  600.   pfill_area3(&ptlist);
  601.   pset_int_colr_ind(windptr->framebrcolour);
  602.   pts[1].x += centresize.x + (2.0 * framesize.x);
  603.   pts[1].y -= centresize.y + (2.0 * framesize.y);
  604.   pts[4].x = pts[3].x;
  605.   pts[4].y = pts[5].y;
  606.   pfill_area3(&ptlist);
  607.  
  608.   /* view */
  609.   pset_pick_id(PTKEWINDOWVIEW);
  610.   pts[2] = ptk_point3(pts[3].x, pts[5].y, centre.z);
  611.   pts[4] = ptk_point3(pts[0].x + framesize.x, pts[3].y, 
  612.                       centre.z);
  613.   pset_int_style(PSTYLE_SOLID);
  614.   pset_int_colr_ind(windptr->backgdcolour);
  615.   pset_edge_flag(PEDGE_ON);
  616.   pset_edge_colr_ind(windptr->edgecolour);
  617.   sets.num_points = 4;
  618.   sets.points = &pts[2];
  619.   ptk_fillareaset3(1, &sets);
  620.  
  621.   /* banner */
  622.   pset_pick_id(PTKEWINDOWBANNER);
  623.   pts[0] = ptk_point3(-windptr->windowsize.x / 2.0, 
  624.                       windptr->windowsize.y /2.0, 0.0);
  625.   pts[1] = ptk_point3(pts[0].x, pts[0].y + windptr->bannerheight, 0.0);
  626.   pts[2] = ptk_point3(pts[0].x + windptr->windowsize.x, pts[1].y, 0.0);
  627.   pts[3] = ptk_point3(pts[2].x, pts[0].y, 0.0);
  628.   sets.num_points = 4;
  629.   sets.points = pts;
  630.   pset_int_colr_ind(windptr->bannercolour);
  631.   ptk_fillareaset3(1, &sets);
  632.   /* Implementation dependent bit - because HP doesn't support
  633.   ** INQUIRE TEXT EXTENT, kludge to size text in window banner.
  634.   */
  635. #ifdef SUN
  636.   bannerbox = ptk_point(windptr->windowsize.x, windptr->bannerheight);
  637. #endif
  638. #ifdef HP
  639.   bannerbox = ptk_point(windptr->windowsize.x, windptr->bannerheight * 0.7);
  640. #endif
  641. #ifdef PEXSI
  642.   bannerbox = ptk_point(windptr->windowsize.x, windptr->bannerheight * 0.7);
  643. #endif
  644.   ptk_computecharheight(windptr->wsid, windptr->titlestring, &bannerbox,
  645.                         windptr->titlefont, &charheight);
  646.   pset_char_ht(charheight);
  647.   txalign.hor = PHOR_CTR;
  648.   txalign.vert = PVERT_BOTTOM;
  649.   pset_text_align(&txalign);
  650.   pset_text_font(windptr->titlefont);
  651.   pset_text_colr_ind(windptr->titlecolour);
  652.   bannercentre = ptk_point(centre.x, windptr->windowsize.y / 2.0);
  653.   ptext(&bannercentre, windptr->titlestring); 
  654. }  /* buildframe */
  655.  
  656. /*--------------------------------------------------------------------------*/
  657.  
  658. static void buildicon()
  659. {
  660.   Ppoint3 boxpos;
  661.   Ppoint boxsize, framesize, iconbox, textpos;
  662.   char str[10];
  663.   Ptext_align align;
  664.   Pfloat charht;
  665.  
  666.   boxpos = ptk_point3(0.5, 0.5, 0.0);
  667.   boxsize = ptk_point(0.95, 0.95);
  668.   framesize = ptk_point(0.05, 0.05);
  669.   ptk_framebox(&boxpos, &boxsize, &framesize, windptr->backgdcolour,
  670.                  windptr->edgecolour, windptr->frametlcolour,
  671.                  windptr->framebrcolour);
  672.   sprintf(str, "%d", windptr->windowid);
  673.   textpos = ptk_point(0.175, 0.875);
  674.   align.hor = PHOR_CTR;
  675.   align.vert = PVERT_HALF;
  676.   pset_text_align(&align);
  677.   iconbox = ptk_point(0.15, 0.15);
  678.   ptk_computecharheight(windptr->wsid, str, &iconbox, 1, &charht);
  679.   pset_char_ht(charht);
  680.   pset_text_colr_ind(1);
  681.   ptext(&textpos, str); 
  682. }  /* buildicon */
  683.  
  684. /*--------------------------------------------------------------------------*/
  685.  
  686. static ptkboolean find_string(C(Pint) structure, C(char *) str)
  687. PreANSI(Pint structure)
  688. PreANSI(char *str)
  689. /*
  690. ** \parambegin
  691. ** \param{}{structure}{window structure id}{IN}
  692. ** \param{}{pickid}{item containing string}{IN}
  693. ** \param{}{strwindow}{string and window data}{IN}
  694. ** \paramend
  695. ** \blurb{Search for string in window items.
  696. ** Returns TRUE if string found, otherwise FALSE.}
  697. */
  698. {
  699.   Pint error, eltptr, numelems;
  700.   Psearch_status stat;
  701.   ptkselcontent elcont;
  702.   Pstore store;
  703.   ptkboolean stop_search, string_found;
  704.   Pelem_type_list include, exclude;
  705.   Pelem_type includeelems[10], excludeelems[10];
  706.  
  707.   eltptr = 0;
  708.   stop_search = FALSE;
  709.   string_found = FALSE;
  710.   numelems = ptk_elemcount(structure);
  711.   do 
  712.   {
  713.     includeelems[0] = PELEM_TEXT3;
  714.     includeelems[1] = PELEM_TEXT;
  715.     include.num_elem_types = 2;
  716.     include.elem_types = includeelems;
  717.     exclude.num_elem_types = 0;
  718.     exclude.elem_types = excludeelems;
  719.  
  720.     pelem_search(structure, eltptr, PDIR_FORWARD, &include, &exclude,
  721.                 &error, &stat, &eltptr);
  722.  
  723.     if (error != 0)
  724.       stop_search = TRUE;
  725.     else 
  726.     if (stat != PSEARCH_STATUS_SUCCESS) 
  727.       stop_search = TRUE;
  728.     else 
  729.     {
  730.       pcreate_store(&error, &store);
  731.       ptk_inqelemtypesizecontent(structure, eltptr, store, &error, 
  732.                                  &elcont);
  733.       if (error == 0) 
  734.       {
  735.         switch (elcont.eltype) 
  736.         {
  737.   
  738.           case PELEM_TEXT:
  739.             if (strcmp(elcont.eldata->text.char_string, str) == 0)
  740.               string_found = TRUE;
  741.             break;
  742.  
  743.           case PELEM_TEXT3:
  744.             if (strcmp(elcont.eldata->text3.char_string, str) == 0)
  745.               string_found = TRUE;
  746.             break;
  747.         }
  748.       }
  749.     }
  750.     eltptr++;
  751.     ptk_delstore(store);
  752.   } while (!string_found && !stop_search && (eltptr <= numelems));
  753.   return string_found;
  754. }  /* find_string */
  755.  
  756. /*--------------------------------------------------------------------------*/
  757.  
  758. static void updateframe()
  759. {
  760.   Ppoint3 wscale;
  761.   Pmatrix3 mat;
  762.   Ppoint position, size;
  763.   Ppoint3 shift;
  764.  
  765.   position = windptr->windowposition;
  766.   size = windptr->windowsize;
  767.   ptk_openstruct(windptr->windowstid);
  768.   ptk_seteditmode(PEDIT_REPLACE);
  769.   pset_elem_ptr(0);
  770.   pset_elem_ptr_label(ptk_stringtoint("label", "globaltran"));
  771.   poffset_elem_ptr(1);
  772.   shift = ptk_point3(position.x, position.y, 0.0);
  773.   ptk_shift3(&shift, PTYPE_REPLACE, mat);
  774.   pset_local_tran3(mat, PTYPE_REPLACE);
  775.   ptk_unseteditmode();
  776.   pdel_elems_labels(ptk_stringtoint("label", "begin-frame"), 
  777.                   ptk_stringtoint("label", "end-frame"));  
  778.   ptk_seteditmode(PEDIT_INSERT);  
  779.   buildframe();
  780.   ptk_unseteditmode();
  781.   ptk_closestruct();
  782.   windptr->viewbox = windptr->viewlims = 
  783.                       ptk_limit3(position.x - (size.x / 2.0),
  784.                                  position.x + (size.x / 2.0),
  785.                                  position.y - (size.y / 2.0),
  786.                                  position.y + (size.y / 2.0),
  787.                                  0.0, 1.0);
  788. }  /* updateframe */
  789.  
  790. /*--------------------------------------------------------------------------*/
  791.  
  792. static void do_structicon()
  793. {
  794.   /* build a spanner! */
  795.   static Ppoint spannerpts[7] = { {-0.05, 0.0}, {-0.05, 0.2},
  796.                   {-0.1, 0.27}, {-0.1, 0.33},
  797.                   {-0.05, 0.4}, {-0.05, 0.33}, 
  798.                                   {0.0, 0.3}};
  799.   Ppoint pts[28], *pts2, *pts3, scale, shift;
  800.   Ppoint_list ptlist;
  801.   Pmatrix3 mat;
  802.   Pint i;
  803.   
  804.   ptlist.num_points = 28;
  805.   ptlist.points = pts;
  806.   pts2 = &pts[7];
  807.   pts3 = &pts[14];
  808.   scale = ptk_point(-1.0, 1.0);
  809.   ptk_scale(&scale, PTYPE_REPLACE, mat);
  810.   for (i = 0; i < 7; i++)
  811.   {
  812.     pts[i] = spannerpts[i];
  813.     pts2[i] = ptk_transform(mat, &spannerpts[6 - i]);
  814.   }
  815.   scale = ptk_point(1.0, -1.0);
  816.   ptk_scale(&scale, PTYPE_REPLACE, mat);
  817.   for (i = 0; i < 7; i++)
  818.   {
  819.     pts3[i] = ptk_transform(mat, &pts2[6 - i]);
  820.     pts3[i + 7] = ptk_transform(mat, &spannerpts[6 - i]);  
  821.   }
  822.   shift = ptk_point(0.5, 0.5);
  823.   ptk_rotate(-45.0, PTKEZAXIS, PTYPE_REPLACE, mat);
  824.   ptk_shift(&shift, PTYPE_POSTCONCAT, mat);
  825.   for (i = 0; i < 28; i++)
  826.     pts[i] = ptk_transform(mat, &pts[i]);
  827.   ppolyline(&ptlist);
  828. }  /* do_structicon */
  829.  
  830. /*--------------------------------------------------------------------------*/
  831.  
  832. static void do_topologyicon()
  833. {
  834.   /* build a simple topology */
  835.   static Ppoint squarepts[5] = { {-0.075, -0.075}, {-0.075, 0.075},
  836.                  {0.075, 0.075}, {0.075, -0.075},
  837.                   {-0.075, -0.075}};
  838.   Ppoint pts[5], shift;
  839.   Ppoint_list ptlist;
  840.   Pmatrix3 mat;
  841.   Pint i;
  842.   
  843.   ptlist.num_points = 5;
  844.   ptlist.points = pts;
  845.  
  846.   shift = ptk_point(0.5, 0.65);
  847.   ptk_shift(&shift, PTYPE_REPLACE, mat);
  848.   for (i = 0; i < 5; i++)
  849.     pts[i] = ptk_transform(mat, &squarepts[i]);
  850.   ppolyline(&ptlist);
  851.  
  852.   shift = ptk_point(0.35, 0.35);
  853.   ptk_shift(&shift, PTYPE_REPLACE, mat);
  854.   for (i = 0; i < 5; i++)
  855.     pts[i] = ptk_transform(mat, &squarepts[i]);
  856.   ppolyline(&ptlist);
  857.  
  858.   shift = ptk_point(0.65, 0.35);
  859.   ptk_shift(&shift, PTYPE_REPLACE, mat);
  860.   for (i = 0; i < 5; i++)
  861.     pts[i] = ptk_transform(mat, &squarepts[i]);
  862.   ppolyline(&ptlist);
  863.  
  864.   ptlist.num_points = 3;
  865.   pts[0] = ptk_point(0.35, 0.425);
  866.   pts[1] = ptk_point(0.5, 0.575);
  867.   pts[2] = ptk_point(0.65, 0.425);
  868.   ppolyline(&ptlist);
  869. }  /* do_topologyicon */
  870.  
  871. /*--------------------------------------------------------------------------*/
  872.  
  873. static void do_terminalicon()
  874. {
  875.   /* a big T */
  876.   static char *str = "T";
  877.   Ppoint textpos, iconbox;
  878.   Pfloat charht;
  879.   Ptext_align align;
  880.   Pint textfont;
  881.  
  882.   /* Implementation dependent code, choose a nice font */
  883. #ifdef SUN
  884.   textfont = PFONT_COMPLEX;
  885. #endif
  886. #ifndef SUN
  887.   /* do for HP and PEXSI */
  888.   textfont = 1;
  889. #endif
  890.   textpos = ptk_point(0.5, 0.5);
  891.   align.hor = PHOR_CTR;
  892.   align.vert = PVERT_HALF;
  893.   pset_text_align(&align);
  894.   iconbox = ptk_point(0.8, 0.8);
  895.   /* Implementation dependent - fit "T" to icon box */
  896. #ifdef SUN
  897.   ptk_computecharheight(windptr->wsid, str, &iconbox, textfont, &charht);
  898.   pset_char_ht(charht);
  899. #endif
  900. #ifdef HP
  901.   pset_char_ht(0.7);
  902. #endif
  903. #ifdef PEXSI
  904.   pset_char_ht(0.7);
  905. #endif
  906.   pset_text_font(textfont);
  907.   ptext(&textpos, str); 
  908. }  /* do_terminalicon */
  909.  
  910. /*--------------------------------------------------------------------------*/
  911.  
  912. static void do_contenticon()
  913. {
  914.   /* build a simple content */
  915.   static Ppoint squarepts[5] = { {0.3, 0.3}, {0.3, 0.7},
  916.                  {0.7, 0.7}, {0.7, 0.3},
  917.                  {0.3, 0.3}};
  918.   Ppoint pts[2];
  919.   Ppoint_list ptlist;
  920.   
  921.   ptlist.num_points = 5;
  922.   ptlist.points = squarepts;
  923.   ppolyline(&ptlist);
  924.  
  925.   ptlist.num_points = 2;
  926.   ptlist.points = pts;
  927.   pts[0] = ptk_point(0.3, 0.4);
  928.   pts[1] = ptk_point(0.7, 0.4);
  929.   ppolyline(&ptlist);
  930.  
  931.   pts[0] = ptk_point(0.3, 0.5);
  932.   pts[1] = ptk_point(0.7, 0.5);
  933.   ppolyline(&ptlist);
  934.  
  935.   pts[0] = ptk_point(0.3, 0.6);
  936.   pts[1] = ptk_point(0.7, 0.6);
  937.   ppolyline(&ptlist);
  938. }  /* do_contenticon */
  939.  
  940. /*--------------------------------------------------------------------------*/
  941.  
  942. static void updateicon()
  943. {
  944.   Ppoint3 wscale, shift;
  945.   Pmatrix3 mat;
  946.  
  947.   if (windptr->defaulticon)
  948.   {
  949.     ptk_openstruct(windptr->iconstid);
  950.     ptk_seteditmode(PEDIT_REPLACE);
  951.     pset_elem_ptr(0);
  952.     pset_elem_ptr_label(ptk_stringtoint("label", "begin-icon"));
  953.     poffset_elem_ptr(-1);
  954.     shift = ptk_point3(-0.5, -0.5, 0.0);
  955.     ptk_shift3(&shift, PTYPE_REPLACE, mat);
  956.     wscale = ptk_point3(windptr->iconsize.x, windptr->iconsize.y, 1.0);
  957.     ptk_scale3(&wscale, PTYPE_POSTCONCAT, mat);
  958.     shift = ptk_point3(windptr->iconposition.x, windptr->iconposition.y, 
  959.                         0.0);
  960.     ptk_shift3(&shift, PTYPE_POSTCONCAT, mat);
  961.     pset_local_tran3(mat, PTYPE_REPLACE);
  962.     ptk_unseteditmode();
  963.     ptk_closestruct();
  964.   }
  965. }  /* updateicon */
  966.  
  967. /*--------------------------------------------------------------------------*/
  968.  
  969. static void updateview()
  970. {
  971.   Pint err;
  972.   Pview_rep3 vrep;
  973.   Plimit3 cliplims;
  974.  
  975.   ptk_pevalvieworientationmatrix3(&windptr->vrp, &windptr->vpn, 
  976.                     &windptr->vup, &err, vrep.ori_matrix);
  977.   vmap.proj_vp = windptr->proj_vp;
  978.   cliplims = windptr->cliplimit;
  979.   if ((windptr->windowtype == PTKESTRUCTWINDOW) ||
  980.       (windptr->windowtype == PTKETOPOLOGYWINDOW))  
  981.   {
  982.     evalviewport(&vmap.proj_vp);
  983.     evalviewport(&cliplims);
  984.   }
  985.   vrep.clip_limit = windptr->viewbox;
  986.   if (windptr->clipxy == PIND_CLIP)
  987.   {
  988.     vrep.clip_limit.x_min = cliplims.x_min;
  989.     vrep.clip_limit.x_max = cliplims.x_max;
  990.     vrep.clip_limit.y_min = cliplims.y_min;
  991.     vrep.clip_limit.y_max = cliplims.y_max;
  992.   }
  993.   if (windptr->clipfront == PIND_CLIP)
  994.     vrep.clip_limit.z_min = cliplims.z_min;
  995.   if (windptr->clipback == PIND_CLIP)
  996.     vrep.clip_limit.z_max = cliplims.z_max;
  997.   vrep.xy_clip = PIND_CLIP;
  998.   vrep.back_clip = vrep.front_clip = PIND_CLIP;
  999.   vmap.win = windptr->win;
  1000.   vmap.proj_type = windptr->proj_type;
  1001.   vmap.proj_ref_point = windptr->proj_ref_point;
  1002.   vmap.view_plane = windptr->viewplane;
  1003.   vmap.front_plane = windptr->frontplane;
  1004.   vmap.back_plane = windptr->backplane;
  1005.   peval_view_map_matrix3(&vmap, &err, vrep.map_matrix);
  1006.   if (windptr->windowstate == PTKEWINDOWOPEN)
  1007.     pset_view_rep3(windptr->wsid, windptr->windowviewind, &vrep);
  1008.   else
  1009.     windptr->viewstate = PVISUAL_ST_DEFER;
  1010. }  /* updateview */
  1011.  
  1012. /*--------------------------------------------------------------------------*/
  1013.  
  1014. static void updatecamera()
  1015. {
  1016.   Pint err;
  1017.   Pview_rep3 vrep;
  1018.   Pmatrix3 twistmat;
  1019.   Ppoint3 origin, initvpn, inittwist;
  1020.  
  1021.   vrp = windptr->ptinterest;
  1022.   vpn = ptk_subv3(&windptr->position, &vrp);
  1023.   vpn = ptk_unitv3(&vpn);
  1024.   ptk_rotatevv3(&windptr->lastvpn, &vpn, PTYPE_REPLACE, twistmat, &err);
  1025.   vup = ptk_transform3(twistmat, &windptr->lastvup);
  1026.   vup = ptk_unitv3(&vup);
  1027.   windptr->lastvup = vup;
  1028.   origin = ptk_point3(0.0, 0.0, 0.0);
  1029.   ptk_rotateline3(&origin, &vpn, windptr->twistangle, PTYPE_POSTCONCAT,
  1030.                   twistmat, &err);
  1031.   vup = ptk_transform3(twistmat, &vup);
  1032.   ptk_pevalvieworientationmatrix3(&vrp, &vpn, &vup, &err, vrep.ori_matrix);
  1033.   windptr->lastvpn = vpn;
  1034.   vrep.clip_limit = windptr->viewlims;
  1035.   vrep.xy_clip = PIND_CLIP;
  1036.   vrep.back_clip = vrep.front_clip = PIND_CLIP;
  1037.   vmap.win = ptk_limit(-windptr->viewvolume.x / 2.0, 
  1038.                         windptr->viewvolume.x / 2.0, 
  1039.                        -windptr->viewvolume.y / 2.0, 
  1040.                         windptr->viewvolume.y / 2.0);
  1041.   vmap.proj_vp = windptr->viewbox;
  1042.   vmap.proj_type = windptr->cameraproj;
  1043.   vmap.proj_ref_point = ptk_point3(0.0, 0.0, windptr->viewvolume.z);
  1044.   vmap.front_plane = windptr->viewvolume.z / 2.0;
  1045.   vmap.view_plane = 0.0;
  1046.   vmap.back_plane = -windptr->viewvolume.z / 2.0;
  1047.  
  1048.   peval_view_map_matrix3(&vmap, &err, vrep.map_matrix);
  1049.  
  1050.   if (windptr->windowstate == PTKEWINDOWOPEN)
  1051.     pset_view_rep3(windptr->wsid, windptr->windowviewind, &vrep);
  1052.   else
  1053.     windptr->viewstate = PVISUAL_ST_DEFER;
  1054. }  /* updatecamera */
  1055.  
  1056. /*--------------------------------------------------------------------------*/
  1057.  
  1058. static void updatewindowview()
  1059. {
  1060.   if (windptr->cameraswitch == PTKECAMERAON)
  1061.     updatecamera();
  1062.   else
  1063.     updateview();
  1064. }  /* updatewindowview */
  1065.  
  1066. /*--------------------------------------------------------------------------*/
  1067.  
  1068. static void initialiseterminal()
  1069. {
  1070.   Pfloat oneline;
  1071.  
  1072.   /* view mapping */
  1073.   windptr->proj_type = PTYPE_PARAL;
  1074.   windptr->proj_ref_point = ptk_point3(windptr->windowsize.x / 2.0,
  1075.                             windptr->windowsize.y / 2.0, 1.0);
  1076.   windptr->win = ptk_limit(0.0, windptr->windowsize.x, 0.0, 
  1077.                              windptr->windowsize.y);
  1078.   windptr->proj_vp = windptr->cliplimit = windptr->viewlims;
  1079.   windptr->backplane = windptr->viewplane = 0.0;
  1080.   windptr->frontplane = 1.0;
  1081.   /* view orientation */
  1082.   oneline = -windptr->windowsize.y/(Pfloat)windptr->term.lines;
  1083.   windptr->vrp = ptk_point3(0.0, -windptr->windowsize.y + 
  1084.                    (oneline * (Pfloat)(windptr->term.visline - 1)), 0.0);
  1085.   windptr->vpn = ptk_point3(0.0, 0.0, 1.0);
  1086.   windptr->vup = ptk_point3(0.0, 1.0, 0.0);
  1087.   /* set view rep */
  1088.   updateview();
  1089. }  /* initialiseterminal */
  1090.  
  1091. /*--------------------------------------------------------------------------*/
  1092. /*------------------------ Camera functions --------------------------------*/
  1093. /*--------------------------------------------------------------------------*/
  1094.  
  1095. /*function:external*/
  1096. extern void ptk_rotatecameraposition(C(Pint) windid, C(Pfloat) angle)
  1097. PreANSI(Pint windid) 
  1098. PreANSI(Pfloat angle)
  1099. /*
  1100. ** \parambegin
  1101. ** \param{Pint}{windid}{window identifier}{IN}
  1102. ** \param{Pfloat}{angle}{rotation angle in degrees}{IN}
  1103. ** \paramend 
  1104. ** \blurb{This function rotates the camera position in a circle centred
  1105. ** at the point of interest and about the axis defined by the function
  1106. ** {\tt ptk\_setpositionaxis}. The amount of rotation is {\tt angle}
  1107. ** degrees and the function is useful for rotating around an object.}
  1108. */
  1109. {
  1110.   Pmatrix3 spinmat, mat;
  1111.   Ppoint3 origin;
  1112.   Ppoint3 shiftprp;
  1113.   Pint err;
  1114.  
  1115.   setwindow(windid);
  1116.   if (windptr != NULL)
  1117.   {
  1118.     /* shift by -(vrp), rotate about arbitrary axis, shift by (vrp) */
  1119.     shiftprp = ptk_scalev3(&windptr->ptinterest, -1.0); 
  1120.     ptk_shift3(&shiftprp, PTYPE_REPLACE, spinmat);
  1121.     origin = ptk_point3(0.0, 0.0, 0.0);
  1122.     ptk_rotateline3(&origin, &windptr->positionaxis, 
  1123.                     angle, PTYPE_POSTCONCAT, spinmat, &err);
  1124.     ptk_shift3(&windptr->ptinterest, PTYPE_POSTCONCAT, spinmat);
  1125.     windptr->position = ptk_transform3(spinmat, &windptr->position);
  1126.     /* transform fixed x and y axes */
  1127.     ptk_rotateline3(&origin, &windptr->positionaxis, angle, 
  1128.                     PTYPE_REPLACE, mat, &err);
  1129.     windptr->xaxis = ptk_transform3(mat, &windptr->xaxis);
  1130.     windptr->yaxis = ptk_transform3(mat, &windptr->yaxis);
  1131.     updatecamera();
  1132.   }
  1133. }  /* ptk_rotatecameraposition */
  1134.  
  1135. /*--------------------------------------------------------------------------*/
  1136.  
  1137. /*function:external*/
  1138. extern void ptk_setpositionaxis(C(Pint) windid, C(Ppoint3 *) axis)
  1139. PreANSI(Pint windid)
  1140. PreANSI(Ppoint3 *axis)
  1141. /*
  1142. ** \parambegin
  1143. ** \param{Pint}{windid}{window identifier}{IN}
  1144. ** \param{Ppoint3 *}{axis}{axis of rotation}{IN}
  1145. ** \paramend 
  1146. ** \blurb{This function sets the axis of rotation for rotating 
  1147. ** the camera position using the function {\tt ptk\_rotatecameraposition}.}
  1148. */
  1149. {
  1150.   setwindow(windid);
  1151.   if (windptr != NULL)
  1152.     windptr->positionaxis = *axis;
  1153. }  /* ptk_setpositionaxis */
  1154.  
  1155. /*--------------------------------------------------------------------------*/
  1156.  
  1157. /*function:external*/
  1158. extern void ptk_setptinterestaxis(C(Pint) windid, C(Ppoint3 *) axis)
  1159. PreANSI(Pint windid)
  1160. PreANSI(Ppoint3 *axis)
  1161. /*
  1162. ** \parambegin
  1163. ** \param{Pint}{windid}{window identifier}{IN}
  1164. ** \param{Ppoint3 *}{axis}{axis of rotation}{IN}
  1165. ** \paramend 
  1166. ** \blurb{This function sets the axis of rotation for rotating 
  1167. ** the camera point of interest using the function
  1168. ** {\tt ptk\_rotatecameraptinterest}.}
  1169. */
  1170. {
  1171.   setwindow(windid);
  1172.   if (windptr != NULL)
  1173.     windptr->ptinterestaxis = *axis;
  1174. }  /* ptk_setptinterestaxis */
  1175.  
  1176. /*--------------------------------------------------------------------------*/
  1177.  
  1178. /*function:external*/
  1179. extern void ptk_scaleviewwindow(C(Pint) windid, C(Pfloat) scalefactor)
  1180. PreANSI(Pint windid) 
  1181. PreANSI(Pfloat scalefactor)
  1182. /*
  1183. ** \parambegin
  1184. ** \param{Pint}{windid}{window identifier}{IN}
  1185. ** \param{Pfloat}{scalefactor}{scale factor}{IN}
  1186. ** \paramend 
  1187. ** \blurb{This function scales the view window uniformly
  1188. ** by {\tt scalefactor}. A scalefactor in the range [0, 1] will
  1189. ** scale down the view window and create a zoom-in effect.
  1190. ** A scalefactor greater than 1.0 will give a zoom-out effect.}
  1191. */
  1192. {
  1193.   setwindow(windid);
  1194.   if (windptr != NULL)
  1195.   {
  1196.     if (scalefactor != 0.0)
  1197.     {
  1198.       windptr->viewvolume.x *= scalefactor;
  1199.       windptr->viewvolume.y *= scalefactor;
  1200.       updatecamera();
  1201.     }
  1202.   }
  1203. }  /* ptk_scaleviewwindow */
  1204.  
  1205. /*--------------------------------------------------------------------------*/
  1206.  
  1207. /*function:external*/
  1208. extern void ptk_rotatecameraptinterest(C(Pint) windid, C(Pfloat) angle)
  1209. PreANSI(Pint windid) 
  1210. PreANSI(Pfloat angle)
  1211. /*
  1212. ** \parambegin
  1213. ** \param{Pint}{windid}{window identifier}{IN}
  1214. ** \param{Pfloat}{angle}{rotation angle in degrees}{IN}
  1215. ** \paramend 
  1216. ** \blurb{This function rotates the camera point of interest in a circle 
  1217. ** centred at the camera position and about the axis defined by the function
  1218. ** {\tt ptk\_setptinterestaxis}. The amount of rotation is {\tt angle}
  1219. ** degrees and the function is useful for panning around a scene.}
  1220. */
  1221. {
  1222.   Pmatrix3 spinmat, mat;
  1223.   Ppoint3 origin;
  1224.   Ppoint3 shiftprp;
  1225.   Pint err;
  1226.  
  1227.   setwindow(windid);
  1228.   if (windptr != NULL)
  1229.   {
  1230.     /* shift by -(prp), rotate about arbitrary axis, shift by (prp) */
  1231.     shiftprp = ptk_scalev3(&windptr->position, -1.0);
  1232.     ptk_shift3(&shiftprp, PTYPE_REPLACE, spinmat);
  1233.     origin = ptk_point3(0.0, 0.0, 0.0);
  1234.     ptk_rotateline3(&origin, &windptr->ptinterestaxis, 
  1235.                     angle, PTYPE_POSTCONCAT, spinmat, &err);
  1236.     ptk_shift3(&windptr->position, PTYPE_POSTCONCAT, spinmat);
  1237.     windptr->ptinterest = ptk_transform3(spinmat, &windptr->ptinterest);
  1238.     /* transform fixed x and y axes */
  1239.     ptk_rotateline3(&origin, &windptr->ptinterestaxis, angle, 
  1240.                     PTYPE_REPLACE, mat, &err);
  1241.     windptr->xaxis = ptk_transform3(mat, &windptr->xaxis);
  1242.     windptr->yaxis = ptk_transform3(mat, &windptr->yaxis);
  1243.     updatecamera();
  1244.   }
  1245. }  /* ptk_rotatecameraptinterest */
  1246.  
  1247. /*--------------------------------------------------------------------------*/
  1248.  
  1249. /*function:external*/
  1250. extern void ptk_rotatecameraupvector(C(Pint) windid, C(Pfloat) angle)
  1251. PreANSI(Pint windid) 
  1252. PreANSI(Pfloat angle)
  1253. /*
  1254. ** \parambegin
  1255. ** \param{Pint}{windid}{window identifier}{IN}
  1256. ** \param{Pfloat}{angle}{rotation angle in degrees}{IN}
  1257. ** \paramend 
  1258. ** \blurb{This function rotates the camera up vector 
  1259. ** about the axis joining the camera position to the point of interest by
  1260. ** {\tt angle} degrees.}
  1261. */
  1262. {
  1263.   Pmatrix3 mat;
  1264.   Pint err;
  1265.   Ppoint3 zaxis;
  1266.  
  1267.   setwindow(windid);
  1268.   if (windptr != NULL)
  1269.   {
  1270.     /* rotate about z axis */
  1271.     windptr->twistangle += angle;
  1272.     zaxis = ptk_crossv3(&windptr->xaxis, &windptr->yaxis);
  1273.     ptk_rotateline3(&origin, &zaxis, angle, PTYPE_REPLACE, mat, &err);
  1274.     windptr->xaxis = ptk_transform3(mat, &windptr->xaxis);
  1275.     windptr->yaxis = ptk_transform3(mat, &windptr->yaxis);
  1276.     updatecamera();
  1277.   }
  1278. }  /* ptk_rotatecameraupvector */
  1279.  
  1280. /*--------------------------------------------------------------------------*/
  1281.  
  1282. /*function:external*/
  1283. extern void ptk_rotatepositionyaxis(C(Pint) windid, C(Pfloat) angle)
  1284. PreANSI(Pint windid) 
  1285. PreANSI(Pfloat angle)
  1286. /*
  1287. ** \parambegin
  1288. ** \param{Pint}{windid}{window identifier}{IN}
  1289. ** \param{Pfloat}{angle}{rotation angle in degrees}{IN}
  1290. ** \paramend 
  1291. ** \blurb{This function rotates the camera position in a circle centred
  1292. ** at the point of interest and about the y axis of a right-handed
  1293. ** coordinate system whose z axis is defined by the camera position and
  1294. ** point of interest.}
  1295. */
  1296. {
  1297.   Pmatrix3 mat;
  1298.   Pint err;
  1299.   Ppoint3 tempaxis;
  1300.  
  1301.   setwindow(windid);
  1302.   if (windptr != NULL)
  1303.   {
  1304.     ptk_inqpositionaxis(windid, &tempaxis, &err);
  1305.     ptk_setpositionaxis(windid, &windptr->yaxis);
  1306.     ptk_rotatecameraposition(windid, -angle);
  1307.     ptk_setpositionaxis(windid, &tempaxis);
  1308.   }
  1309. }  /* ptk_rotatepositionyaxis */
  1310.  
  1311. /*--------------------------------------------------------------------------*/
  1312.  
  1313. /*function:external*/
  1314. extern void ptk_rotatepositionxaxis(C(Pint) windid, C(Pfloat) angle)
  1315. PreANSI(Pint windid) 
  1316. PreANSI(Pfloat angle)
  1317. /*
  1318. ** \parambegin
  1319. ** \param{Pint}{windid}{window identifier}{IN}
  1320. ** \param{Pfloat}{angle}{rotation angle in degrees}{IN}
  1321. ** \paramend 
  1322. ** \blurb{This function rotates the camera position in a circle centred
  1323. ** at the point of interest and about the x axis of a right-handed
  1324. ** coordinate system whose z axis is defined by the camera position and
  1325. ** point of interest.}
  1326. */
  1327. {
  1328.   Pmatrix3 mat;
  1329.   Pint err;
  1330.   Ppoint3 tempaxis;
  1331.  
  1332.   setwindow(windid);
  1333.   if (windptr != NULL)
  1334.   {
  1335.     ptk_inqpositionaxis(windid, &tempaxis, &err);
  1336.     ptk_setpositionaxis(windid, &windptr->xaxis);
  1337.     ptk_rotatecameraposition(windid, -angle);
  1338.     ptk_setpositionaxis(windid, &tempaxis);
  1339.   }
  1340. }  /* ptk_rotatepositionxaxis */
  1341.  
  1342. /*--------------------------------------------------------------------------*/
  1343.  
  1344. /*function:external*/
  1345. extern void ptk_rotateptinterestyaxis(C(Pint) windid, C(Pfloat) angle)
  1346. PreANSI(Pint windid) 
  1347. PreANSI(Pfloat angle)
  1348. /*
  1349. ** \parambegin
  1350. ** \param{Pint}{windid}{window identifier}{IN}
  1351. ** \param{Pfloat}{angle}{rotation angle in degrees}{IN}
  1352. ** \paramend 
  1353. ** \blurb{This function rotates the camera point of interest
  1354. ** in a circle centred
  1355. ** at the camera position and about the y axis of a right-handed
  1356. ** coordinate system whose z axis is defined by the camera position and
  1357. ** point of interest.}
  1358. */
  1359. {
  1360.   Pmatrix3 mat;
  1361.   Pint err;
  1362.   Ppoint3 tempaxis;
  1363.  
  1364.   setwindow(windid);
  1365.   if (windptr != NULL)
  1366.   {
  1367.     ptk_inqptinterestaxis(windid, &tempaxis, &err);
  1368.     ptk_setptinterestaxis(windid, &windptr->yaxis);
  1369.     ptk_rotatecameraptinterest(windid, -angle);
  1370.     ptk_setptinterestaxis(windid, &tempaxis);
  1371.   }
  1372. }  /* ptk_rotateptinterestyaxis */
  1373.  
  1374. /*--------------------------------------------------------------------------*/
  1375.  
  1376. /*function:external*/
  1377. extern void ptk_rotateptinterestxaxis(C(Pint) windid, C(Pfloat) angle)
  1378. PreANSI(Pint windid) 
  1379. PreANSI(Pfloat angle)
  1380. /*
  1381. ** \parambegin
  1382. ** \param{Pint}{windid}{window identifier}{IN}
  1383. ** \param{Pfloat}{angle}{rotation angle in degrees}{IN}
  1384. ** \paramend 
  1385. ** \blurb{This function rotates the camera point of interest
  1386. ** in a circle centred
  1387. ** at the camera position and about the x axis of a right-handed
  1388. ** coordinate system whose z axis is defined by the camera position and
  1389. ** point of interest.}
  1390. */
  1391. {
  1392.   Pmatrix3 mat;
  1393.   Pint err;
  1394.   Ppoint3 tempaxis;
  1395.  
  1396.   setwindow(windid);
  1397.   if (windptr != NULL)
  1398.   {
  1399.     ptk_inqptinterestaxis(windid, &tempaxis, &err);
  1400.     ptk_setptinterestaxis(windid, &windptr->xaxis);
  1401.     ptk_rotatecameraptinterest(windid, -angle);
  1402.     ptk_setptinterestaxis(windid, &tempaxis);
  1403.   }
  1404. }  /* ptk_rotateptinterestxaxis */
  1405.  
  1406. /*--------------------------------------------------------------------------*/
  1407.  
  1408. /*function:external*/
  1409. extern void ptk_shiftcamera(C(Pint) windid, C(Ppoint3 *) shift)
  1410. PreANSI(Pint windid) 
  1411. PreANSI(Ppoint3 *shift)
  1412. /*
  1413. ** \parambegin
  1414. ** \param{Pint}{windid}{window identifier}{IN}
  1415. ** \param{Ppoint3 *}{shift}{shift factor}{IN}
  1416. ** \paramend 
  1417. ** \blurb{This function shifts the camera point of interest
  1418. ** and camera position about the axes of a right-handed
  1419. ** coordinate system whose z axis is defined by the camera position 
  1420. ** and point of interest.}
  1421. */
  1422. {
  1423.   Pmatrix3 mat;
  1424.   Pint err;
  1425.   Ppoint3 newshift;
  1426.  
  1427.   setwindow(windid);
  1428.   if (windptr != NULL)
  1429.   {
  1430.     ptk_0to3pt(&origin, &windptr->xaxis, &windptr->yaxis, PTYPE_REPLACE,
  1431.                mat);
  1432.     newshift = ptk_transform3(mat, shift);
  1433.     ptk_shift3(&newshift, PTYPE_REPLACE, mat);
  1434.     windptr->position = ptk_transform3(mat, &windptr->position);
  1435.     windptr->ptinterest = ptk_transform3(mat, &windptr->ptinterest);
  1436.     updatecamera();
  1437.   }
  1438. }  /* ptk_shiftcamera */
  1439.  
  1440. /*--------------------------------------------------------------------------*/
  1441.  
  1442. /*function:external*/
  1443. extern void ptk_setcameraposition(C(Pint) windid, C(Ppoint3 *) position)
  1444. PreANSI(Pint windid)
  1445. PreANSI(Ppoint3 *position)
  1446. /*
  1447. ** \parambegin
  1448. ** \param{Pint}{windid}{window identifier}{IN}
  1449. ** \param{Ppoint3 *}{position}{camera position}{IN}
  1450. ** \paramend 
  1451. ** \blurb{This function sets the camera position to {\tt position}
  1452. ** which is given in World Coordinates.}
  1453. */
  1454. {
  1455.   setwindow(windid);
  1456.   if (windptr != NULL)
  1457.   {
  1458.     windptr->position = *position;
  1459.     /* reset last vectors to defaults */
  1460.     windptr->lastvpn = ptk_point3(0.0, 0.0, 1.0);
  1461.     windptr->lastvup = ptk_point3(0.0, 1.0, 0.0);
  1462.     windptr->twistangle = 0.0;
  1463.     updatecamera();
  1464.   }
  1465. }  /* ptk_setcameraposition */
  1466.  
  1467. /*--------------------------------------------------------------------------*/
  1468.  
  1469. /*function:external*/
  1470. extern void ptk_setcameraptinterest(C(Pint) windid, C(Ppoint3 *) ptinterest)
  1471. PreANSI(Pint windid)
  1472. PreANSI(Ppoint3 *ptinterest)
  1473. /*
  1474. ** \parambegin
  1475. ** \param{Pint}{windid}{window identifier}{IN}
  1476. ** \param{Ppoint3 *}{ptinterest}{point of interest}{IN}
  1477. ** \paramend 
  1478. ** \blurb{This function sets the camera point of interest to
  1479. ** {\tt ptinterest} which is given in World Corrdinates.}
  1480. */
  1481. {
  1482.   setwindow(windid);
  1483.   if (windptr != NULL)
  1484.   {
  1485.     windptr->ptinterest = *ptinterest;
  1486.     updatecamera();
  1487.   }
  1488. }  /* ptk_setcameraptinterest */
  1489.  
  1490. /*--------------------------------------------------------------------------*/
  1491.  
  1492. /*function:external*/
  1493. extern void ptk_setcameraprojtype(C(Pint) windid, C(Pproj_type) proj)
  1494. PreANSI(Pint windid)
  1495. PreANSI(Pproj_type proj)
  1496. /*
  1497. ** \parambegin
  1498. ** \param{Pint}{windid}{window identifier}{IN}
  1499. ** \param{Pproj\_type}{proj}{camera projection type}{IN}
  1500. ** \paramend 
  1501. ** \blurb{This function sets the projection type of the view given by the
  1502. ** camera to PARALLEL or PERSPECTIVE. The default is PARALLEL.}
  1503. */
  1504. {
  1505.   setwindow(windid);
  1506.   if (windptr != NULL)
  1507.   {
  1508.     windptr->cameraproj = proj;
  1509.     updatecamera();
  1510.   }
  1511. }  /* ptk_setcameraprojtype */
  1512.   
  1513. /*--------------------------------------------------------------------------*/
  1514.   
  1515. /*function:external*/
  1516. extern void ptk_setcamerastate(C(Pint) windid, 
  1517.                                C(ptkecamerastate) cameraswitch)
  1518. PreANSI(Pint windid)
  1519. PreANSI(ptkecamerastate cameraswitch)
  1520. /*
  1521. ** \parambegin
  1522. ** \param{Pint}{windid}{window identifier}{IN}
  1523. ** \param{ptkecamerastate}{cameraswitch}{camera on or off}{IN}
  1524. ** \paramend 
  1525. ** \blurb{This function sets the camera of the window {\tt windid}
  1526. ** to ON or OFF. The default is ON.}
  1527. */
  1528. {
  1529.   setwindow(windid);
  1530.   if (windptr != NULL)
  1531.   {
  1532.     windptr->cameraswitch = cameraswitch;
  1533.     updatewindowview();
  1534.   }
  1535. }  /* ptk_setcamerastate */
  1536.  
  1537. /*--------------------------------------------------------------------------*/
  1538.  
  1539. /*function:external*/
  1540. extern void ptk_setcameraworld(C(Pint) windid, C(Pint_list *) stids)
  1541. PreANSI(Pint windid)
  1542. PreANSI(Pint_list *stids)
  1543. /*
  1544. ** \parambegin
  1545. ** \param{Pint}{windid}{window identifier}{IN}
  1546. ** \param{Pint\_list *}{stids}{structure identifier list}{IN}
  1547. ** \paramend 
  1548. ** \blurb{This function initialises the view volume of the camera so 
  1549. ** that it contains the combined bounding box of all the 
  1550. ** structures and structure networks in {\tt stids}. The camera position
  1551. ** and point of interest are set accordingly.}
  1552. */
  1553. {
  1554.   Pint i;
  1555.   Plimit3 cameraworld, stlimits;
  1556.  
  1557.   setwindow(windid);
  1558.   if (windptr != NULL)
  1559.   {
  1560.     cameraworld = ptk_limit3(10000.0, -10000.0, 10000.0, -10000.0, 10000.0,
  1561.                              -10000.0);
  1562.     for (i = 0; i < stids->num_ints; i++)
  1563.     {
  1564.       if (ptk_boundingbox(stids->ints[i], &stlimits, TRUE))
  1565.       {
  1566.         if (stlimits.x_min < cameraworld.x_min)
  1567.           cameraworld.x_min = stlimits.x_min;
  1568.         if (stlimits.y_min < cameraworld.y_min)
  1569.           cameraworld.y_min = stlimits.y_min;
  1570.         if (stlimits.z_min < cameraworld.z_min)
  1571.           cameraworld.z_min = stlimits.z_min;
  1572.         if (stlimits.x_max > cameraworld.x_max)
  1573.           cameraworld.x_max = stlimits.x_max;
  1574.         if (stlimits.y_max > cameraworld.y_max)
  1575.           cameraworld.y_max = stlimits.y_max;
  1576.         if (stlimits.z_max > cameraworld.z_max)
  1577.           cameraworld.z_max = stlimits.z_max;
  1578.       }
  1579.     }
  1580.     evalviewvolume(&cameraworld, TRUE);
  1581.     updatecamera();
  1582.   }
  1583. }  /* ptk_setcameraworld */
  1584.  
  1585. /*--------------------------------------------------------------------------*/
  1586.  
  1587. /*function:external*/
  1588. extern void ptk_setcameralimits(C(Pint) windid, C(Plimit3 *) limits,
  1589.                                 C(ptkboolean) adjust)
  1590. PreANSI(Pint windid)
  1591. PreANSI(Plimit3 *limits)
  1592. PreANSI(ptkboolean adjust)
  1593. /*
  1594. ** \parambegin
  1595. ** \param{Pint}{windid}{window identifier}{IN}
  1596. ** \param{Plimit3 *}{limits}{camera viewing limits in WC}{IN}
  1597. ** \param{ptkboolean}{adjust}{adjust given limits}{IN}
  1598. ** \paramend 
  1599. ** \blurb{This function initialises the view volume of the camera
  1600. ** to the specified bounding box given in World Coordinates. If 
  1601. ** {\tt adjust} is set to TRUE then the bounding box will be adjusted 
  1602. ** to be the bounding box of a sphere which encloses the original box.
  1603. ** The camera position and point of interest are set accordingly.}
  1604. */
  1605. {
  1606.   Pint i;
  1607.  
  1608.   setwindow(windid);
  1609.   if (windptr != NULL)
  1610.   {
  1611.     evalviewvolume(limits, adjust);
  1612.     updatecamera();
  1613.   }
  1614. }  /* ptk_setcameralimits */
  1615.  
  1616. /*--------------------------------------------------------------------------*/
  1617.  
  1618. /*function:external*/
  1619. extern void ptk_resetcamera(C(Pint) windid)
  1620. PreANSI(Pint windid)
  1621. /*
  1622. ** \parambegin
  1623. ** \param{Pint}{windid}{window identifier}{IN}
  1624. ** \paramend 
  1625. ** \blurb{This function resets the camera variables to their default
  1626. ** values. The camera view volume is left unchanged.}
  1627. */
  1628. {
  1629.   Pint i;
  1630.  
  1631.   setwindow(windid);
  1632.   if (windptr != NULL)
  1633.   {
  1634.     windptr->position = ptk_point3(0.5, 0.5, 2.0);
  1635.     windptr->ptinterest = ptk_point3(0.5, 0.5, 0.5);
  1636.     windptr->positionaxis = ptk_point3(0.0, 1.0, 0.0);
  1637.     windptr->ptinterestaxis = ptk_point3(0.0, 1.0, 0.0);
  1638.     windptr->lastvpn = ptk_point3(0.0, 0.0, 1.0);
  1639.     windptr->lastvup = ptk_point3(0.0, 1.0, 0.0);
  1640.     windptr->xaxis = ptk_point3(1.0, 0.0, 0.0);
  1641.     windptr->yaxis = ptk_point3(0.0, 1.0, 0.0);
  1642.     windptr->swivelangle = windptr->spinangle = 
  1643.     windptr->twistangle = 0.0;
  1644.     windptr->cameraproj = PTYPE_PARAL;
  1645.     if (windptr->cameraswitch == PTKECAMERAON)
  1646.       updatecamera();
  1647.   }
  1648. }  /* ptk_resetcamera */
  1649.  
  1650. /*--------------------------------------------------------------------------*/
  1651.  
  1652. /*function:external*/
  1653. extern void ptk_inqcameraposition(C(Pint) windid, C(Ppoint3 *) position,
  1654.                                   C(Pint *) err) 
  1655. PreANSI(Pint windid)
  1656. PreANSI(Ppoint3 *position)
  1657. PreANSI(Pint *err)
  1658. /*
  1659. ** \parambegin
  1660. ** \param{Pint}{windid}{window identifier}{IN}
  1661. ** \param{Ppoint3 *}{position}{camera position}{OUT}
  1662. ** \param{Pint *}{err}{error indicator}{OUT}
  1663. ** \paramend
  1664. ** \blurb{This function may be used to obtain the camera position in
  1665. ** World Coordinates.
  1666. ** The error code = 1 if {\tt windid} doesn't exist.}
  1667. */
  1668. {
  1669.   *err = 0;
  1670.   setwindow(windid);
  1671.   if (windptr != NULL)
  1672.     *position = windptr->position;
  1673.   else
  1674.     *err = 1;
  1675. }  /* ptk_inqcameraposition */
  1676.  
  1677. /*--------------------------------------------------------------------------*/
  1678.  
  1679. /*function:external*/
  1680. extern void ptk_inqcameraptinterest(C(Pint) windid, C(Ppoint3 *) ptinterest,
  1681.                                   C(Pint *) err) 
  1682. PreANSI(Pint windid)
  1683. PreANSI(Ppoint3 *ptinterest)
  1684. PreANSI(Pint *err)
  1685. /*
  1686. ** \parambegin
  1687. ** \param{Pint}{windid}{window identifier}{IN}
  1688. ** \param{Ppoint3 *}{ptinterest}{camera point of interest}{OUT}
  1689. ** \param{Pint *}{err}{error indicator}{OUT}
  1690. ** \paramend
  1691. ** \blurb{This function may be used to obtain the camera point of interest
  1692. ** in World Coordinates.
  1693. ** The error code = 1 if {\tt windid} doesn't exist.}
  1694. */
  1695. {
  1696.   *err = 0;
  1697.   setwindow(windid);
  1698.   if (windptr != NULL)
  1699.     *ptinterest = windptr->ptinterest;
  1700.   else
  1701.     *err = 1;
  1702. }  /* ptk_inqcameraptinterest */
  1703.  
  1704. /*--------------------------------------------------------------------------*/
  1705.  
  1706. /*function:external*/
  1707. extern void ptk_inqcameraprojtype(C(Pint) windid, C(Pproj_type *) projtype,
  1708.                                   C(Pint *) err) 
  1709. PreANSI(Pint windid)
  1710. PreANSI(Pproj_type *projtype)
  1711. PreANSI(Pint *err)
  1712. /*
  1713. ** \parambegin
  1714. ** \param{Pint}{windid}{window identifier}{IN}
  1715. ** \param{Pproj\_type *}{projtype}{camera projection type}{OUT}
  1716. ** \param{Pint *}{err}{error indicator}{OUT}
  1717. ** \paramend
  1718. ** \blurb{This function may be used to obtain the camera view projection
  1719. ** type which is either PARALLEL or PERSPECTIVE.
  1720. ** The error code = 1 if {\tt windid} doesn't exist.}
  1721. */
  1722. {
  1723.   *err = 0;
  1724.   setwindow(windid);
  1725.   if (windptr != NULL)
  1726.     *projtype = windptr->proj_type;
  1727.   else
  1728.     *err = 1;
  1729. }  /* ptk_inqcameraprojtype */
  1730.  
  1731. /*--------------------------------------------------------------------------*/
  1732.  
  1733. /*function:external*/
  1734. extern void ptk_inqcamerastate(C(Pint) windid, 
  1735.                   C(ptkecamerastate *) cameraswitch, C(Pint *) err) 
  1736. PreANSI(Pint windid)
  1737. PreANSI(ptkecamerastate *cameraswitch)
  1738. PreANSI(Pint *err)
  1739. /*
  1740. ** \parambegin
  1741. ** \param{Pint}{windid}{window identifier}{IN}
  1742. ** \param{ptkecamerastate *}{cameraswitch}{camera ON/OFF switch}{OUT}
  1743. ** \param{Pint *}{err}{error indicator}{OUT}
  1744. ** \paramend
  1745. ** \blurb{This function may be used to obtain the camera state which is
  1746. ** either ON or OFF.
  1747. ** The error code = 1 if {\tt windid} doesn't exist.}
  1748. */
  1749. {
  1750.   *err = 0;
  1751.   setwindow(windid);
  1752.   if (windptr != NULL)
  1753.     *cameraswitch = windptr->cameraswitch;
  1754.   else
  1755.     *err = 1;
  1756. }  /* ptk_inqcamerastate */
  1757.  
  1758. /*--------------------------------------------------------------------------*/
  1759.  
  1760. /*function:external*/
  1761. extern void ptk_inqcameralimits(C(Pint) windid, C(Plimit3 *) limits,
  1762.                                   C(Pint *) err) 
  1763. PreANSI(Pint windid)
  1764. PreANSI(Plimit3 *limits)
  1765. PreANSI(Pint *err)
  1766. /*
  1767. ** \parambegin
  1768. ** \param{Pint}{windid}{window identifier}{IN}
  1769. ** \param{Plimit3 *}{limits}{camera world limits}{OUT}
  1770. ** \param{Pint *}{err}{error indicator}{OUT}
  1771. ** \paramend
  1772. ** \blurb{This function may be used to obtain the camera view volume.
  1773. ** This defines the volume of a scene that the camera knows about
  1774. ** and is returned in World Coordinates.
  1775. ** The error code = 1 if {\tt windid} doesn't exist.}
  1776. */
  1777. {
  1778.   *err = 0;
  1779.   setwindow(windid);
  1780.   if (windptr != NULL)
  1781.   {
  1782.     *limits = ptk_limit3(windptr->ptinterest.x - windptr->viewvolume.x / 2.0,
  1783.                   windptr->ptinterest.x + windptr->viewvolume.x / 2.0,
  1784.                   windptr->ptinterest.y - windptr->viewvolume.y / 2.0,
  1785.                   windptr->ptinterest.y + windptr->viewvolume.y / 2.0,
  1786.                   windptr->ptinterest.z - windptr->viewvolume.z / 2.0,
  1787.                   windptr->ptinterest.z + windptr->viewvolume.z / 2.0);
  1788.   }
  1789.   else
  1790.     *err = 1;
  1791. }  /* ptk_inqcameralimits */
  1792.  
  1793. /*--------------------------------------------------------------------------*/
  1794.  
  1795. /*function:external*/
  1796. extern void ptk_inqpositionaxis(C(Pint) windid, C(Ppoint3 *) axis,
  1797.                                   C(Pint *) err) 
  1798. PreANSI(Pint windid)
  1799. PreANSI(Ppoint3 *axis)
  1800. PreANSI(Pint *err)
  1801. /*
  1802. ** \parambegin
  1803. ** \param{Pint}{windid}{window identifier}{IN}
  1804. ** \param{Ppoint3 *}{axis}{camera position axis of rotation}{OUT}
  1805. ** \param{Pint *}{err}{error indicator}{OUT}
  1806. ** \paramend
  1807. ** \blurb{This function may be used to obtain the axis of rotation
  1808. ** which is used to rotate the camera position in the function
  1809. ** {\tt ptk\_rotatecameraposition}.
  1810. ** The error code = 1 if {\tt windid} doesn't exist.}
  1811. */
  1812. {
  1813.   *err = 0;
  1814.   setwindow(windid);
  1815.   if (windptr != NULL)
  1816.     *axis = windptr->positionaxis;
  1817.   else
  1818.     *err = 1;
  1819. }  /* ptk_inqpositionaxis */
  1820.  
  1821. /*--------------------------------------------------------------------------*/
  1822.  
  1823. /*function:external*/
  1824. extern void ptk_inqptinterestaxis(C(Pint) windid, C(Ppoint3 *) axis,
  1825.                                   C(Pint *) err) 
  1826. PreANSI(Pint windid)
  1827. PreANSI(Ppoint3 *axis)
  1828. PreANSI(Pint *err)
  1829. /*
  1830. ** \parambegin
  1831. ** \param{Pint}{windid}{window identifier}{IN}
  1832. ** \param{Ppoint3 *}{axis}{camera point of interest axis of rotation}{OUT}
  1833. ** \param{Pint *}{err}{error indicator}{OUT}
  1834. ** \paramend
  1835. ** \blurb{This function may be used to obtain the axis of rotation
  1836. ** which is used to rotate the camera point of interest in the function
  1837. ** {\tt ptk\_rotatecameraptinterest}.
  1838. ** The error code = 1 if {\tt windid} doesn't exist.}
  1839. */
  1840. {
  1841.   *err = 0;
  1842.   setwindow(windid);
  1843.   if (windptr != NULL)
  1844.     *axis = windptr->ptinterestaxis;
  1845.   else
  1846.     *err = 1;
  1847. }  /* ptk_inqptinterestaxis */
  1848.  
  1849. /*--------------------------------------------------------------------------*/
  1850.  
  1851. /*function:external*/
  1852. extern void ptk_inqwindowviewrep(C(Pint) windid, C(Pview_rep3 *) rep,
  1853.                                   C(Pint *) err) 
  1854. PreANSI(Pint windid)
  1855. PreANSI(Pview_rep3 *rep)
  1856. PreANSI(Pint *err)
  1857. /*
  1858. ** \parambegin
  1859. ** \param{Pint}{windid}{window identifier}{IN}
  1860. ** \param{Pview\_rep3 *}{rep}{window view representation}{OUT}
  1861. ** \param{Pint *}{err}{error indicator}{OUT}
  1862. ** \paramend
  1863. ** \blurb{This function may be used to obtain the viewing parameters
  1864. ** which are used to set the window view when the camera is switched
  1865. ** OFF.
  1866. ** The error code = 1 if {\tt windid} doesn't exist.}
  1867. */
  1868. {
  1869.   Pview_map3 vmap;
  1870.  
  1871.   *err = 0;
  1872.   setwindow(windid);
  1873.   if (windptr != NULL)
  1874.   {
  1875.     ptk_pevalvieworientationmatrix3(&windptr->vrp, &windptr->vpn, 
  1876.                      &windptr->vup, err, rep->ori_matrix);
  1877.     vmap.proj_vp = windptr->proj_vp;
  1878.     vmap.win = windptr->win;
  1879.     vmap.proj_type = windptr->proj_type;
  1880.     vmap.proj_ref_point = windptr->proj_ref_point;
  1881.     vmap.view_plane = windptr->viewplane;
  1882.     vmap.front_plane = windptr->frontplane;
  1883.     vmap.back_plane = windptr->backplane;
  1884.     peval_view_map_matrix3(&vmap, err, rep->map_matrix);
  1885.     rep->clip_limit = windptr->cliplimit;
  1886.     rep->xy_clip = windptr->clipxy;
  1887.     rep->back_clip = windptr->clipback;
  1888.     rep->front_clip = windptr->clipfront;
  1889.   }
  1890.   else
  1891.     *err = 1;
  1892. }  /* ptk_inqwindowviewrep */
  1893.  
  1894. /*--------------------------------------------------------------------------*/
  1895. /*------------------------ Viewing functions -------------------------------*/
  1896. /*--------------------------------------------------------------------------*/
  1897.  
  1898. /*function:external*/
  1899. extern void ptk_setvieworientation3(C(Pint) windid, C(Ppoint3 *) vrp, 
  1900.             C(Ppoint3 *) vpn, C(Ppoint3 *) vup, C(Pint *) error)
  1901. PreANSI(Pint windid)
  1902. PreANSI(Ppoint3 *vrp)
  1903. PreANSI(Ppoint3 *vpn)
  1904. PreANSI(Ppoint3 *vup)
  1905. PreANSI(Pint *error)
  1906. /*
  1907. ** \parambegin
  1908. ** \param{Pint}{windid}{window identifier}{IN}
  1909. ** \param{Ppoint3 *}{vrp}{view reference point}{IN}
  1910. ** \param{Ppoint3 *}{vpn}{view plane normal}{IN}
  1911. ** \param{Ppoint3 *}{vup}{view up vector}{IN}
  1912. ** \param{Pint *}{error}{error indicator}{OUT}
  1913. ** \paramend 
  1914. ** \blurb{This function sets the window view orientation values. 
  1915. ** The camera must be switched OFF for these values to be set.
  1916. ** The error code is a standard PHIGS error code.}
  1917. */
  1918. {
  1919.   Pmatrix3 orimat;
  1920.  
  1921.   setwindow(windid);
  1922.   if (windptr != NULL)
  1923.   {
  1924.     ptk_pevalvieworientationmatrix3(vrp, vpn, vup, error, orimat);
  1925.     if (*error == 0)
  1926.     {
  1927.       windptr->vrp = *vrp;
  1928.       windptr->vpn = *vpn;
  1929.       windptr->vup = *vup;
  1930.       updateview();
  1931.     }
  1932.   }
  1933. }  /* ptk_setvieworientation3 */
  1934.  
  1935. /*--------------------------------------------------------------------------*/
  1936.  
  1937. /*function:external*/
  1938. extern void ptk_setviewmapping3(C(Pint) windid, C(Plimit *) window,
  1939.             C(Plimit3 *) viewport, C(Pproj_type) proj, C(Ppoint3 *) prp, 
  1940.             C(Pfloat) viewplane, C(Pfloat) backplane, C(Pfloat) frontplane, 
  1941.             C(Pint *) error)
  1942. PreANSI(Pint windid)
  1943. PreANSI(Plimit *window)
  1944. PreANSI(Plimit3 *viewport)
  1945. PreANSI(Pproj_type proj)
  1946. PreANSI(Ppoint3 *prp)
  1947. PreANSI(Pfloat viewplane)
  1948. PreANSI(Pfloat backplane)
  1949. PreANSI(Pfloat frontplane)
  1950. PreANSI(Pint *error)
  1951. /*
  1952. ** \parambegin
  1953. ** \param{Pint}{windid}{window identifier}{IN}
  1954. ** \param{Plimit *}{window}{view window}{IN}
  1955. ** \param{Plimit3 *}{viewport}{projection viewport}{IN}
  1956. ** \param{Pproj\_type}{proj}{projection type}{IN}
  1957. ** \param{Ppoint3 *}{prp}{projection reference point}{IN}
  1958. ** \param{Pfloat}{viewplane}{view plane distance}{IN}
  1959. ** \param{Pfloat}{backplane}{back plane distance}{IN}
  1960. ** \param{Pfloat}{frontplane}{front plane distance}{IN}
  1961. ** \param{Pint *}{error}{error indicator}{OUT}
  1962. ** \paramend 
  1963. ** \blurb{This function sets the window view mapping values.
  1964. ** The camera must be switched OFF for these values to be set.
  1965. ** The largest square within the window is defined to be the
  1966. ** device coordinates area which the view maps onto.
  1967. ** The error code is a standard PHIGS error code.}
  1968. */
  1969. {
  1970.   Pmatrix3 mapmat;
  1971.   Pview_map3 mapping;
  1972.  
  1973.   setwindow(windid);
  1974.   if (windptr != NULL)
  1975.   {
  1976.     mapping.win = *window;
  1977.     mapping.proj_type = proj;
  1978.     mapping.proj_ref_point = *prp;
  1979.     mapping.view_plane = viewplane;
  1980.     mapping.back_plane = backplane;
  1981.     mapping.front_plane = frontplane;
  1982.     mapping.proj_vp = *viewport;
  1983.     evalviewport(&mapping.proj_vp);
  1984.     peval_view_map_matrix3(&mapping, error, mapmat);
  1985.     if (*error == 0)
  1986.     {
  1987.       windptr->win = *window;
  1988.       windptr->proj_vp = *viewport;
  1989.       windptr->proj_type = proj;
  1990.       windptr->proj_ref_point = *prp;
  1991.       windptr->viewplane = viewplane;
  1992.       windptr->backplane = backplane;
  1993.       windptr->frontplane = frontplane;
  1994.       updateview();
  1995.     }
  1996.   }
  1997. }  /* ptk_setviewmapping3 */
  1998.  
  1999. /*--------------------------------------------------------------------------*/
  2000.  
  2001. /*function:external*/
  2002. extern void ptk_setviewclipping3(C(Pint) windid, C(Plimit3 *) cliplims,
  2003.             C(Pclip_ind) clipxy, C(Pclip_ind) clipback, C(Pclip_ind) clipfront)
  2004. PreANSI(Pint windid)
  2005. PreANSI(Plimit3 *cliplims)
  2006. PreANSI(Pclip_ind clipxy)
  2007. PreANSI(Pclip_ind clipfront)
  2008. PreANSI(Pclip_ind clipback)
  2009. /*
  2010. ** \parambegin
  2011. ** \param{Pint}{windid}{window identifier}{IN}
  2012. ** \param{Plimit3 *}{cliplims}{view clipping limits}{IN}
  2013. ** \param{Pclip\_ind}{clipxy}{x-y clipping indicator}{IN}
  2014. ** \param{Pclip\_ind}{clipback}{back plane clipping indicator}{IN}
  2015. ** \param{Pclip\_ind}{clipfront}{front plane clipping indicator}{IN}
  2016. ** \paramend 
  2017. ** \blurb{This function sets the window view clipping values. 
  2018. ** The camera must be switched OFF for these values to be set.}
  2019. */
  2020. {
  2021.   setwindow(windid);
  2022.   if (windptr != NULL)
  2023.   {
  2024.     windptr->cliplimit = *cliplims;
  2025.     windptr->clipxy = clipxy;
  2026.     windptr->clipback = clipback;
  2027.     windptr->clipfront = clipfront;
  2028.     updateview();
  2029.   }
  2030. }  /* ptk_setviewclipping3 */
  2031.  
  2032. /*--------------------------------------------------------------------------*/
  2033. /*------------------- Window system functions ------------------------------*/
  2034. /*--------------------------------------------------------------------------*/
  2035.  
  2036. static void createwindow(C(Pint) wsid, C(Pint) windid, C(Ppoint *) size,
  2037.                              C(Ppoint *) position, C(Pint) backgdcolour,
  2038.       C(Pint) edgecolour, C(Pint) frametlcolour, C(Pint) framebrcolour,
  2039.       C(Pint) titlecolour, C(char *) titlestring)
  2040. PreANSI(Pint wsid)
  2041. PreANSI(Pint windid)
  2042. PreANSI(Ppoint *size)
  2043. PreANSI(Ppoint *position)
  2044. PreANSI(Pint backgdcolour)
  2045. PreANSI(Pint edgecolour)
  2046. PreANSI(Pint frametlcolour)
  2047. PreANSI(Pint framebrcolour)
  2048. PreANSI(Pint titlecolour)
  2049. PreANSI(char *titlestring)
  2050. /* 
  2051. ** \parambegin
  2052. ** \param{Pint}{wsid}{workstation identifier}{IN}
  2053. ** \param{Pint}{windid}{window identifier}{IN}
  2054. ** \param{Ppoint *}{size}{window size}{IN}
  2055. ** \param{Ppoint *}{position}{window position}{IN}
  2056. ** \param{Pint}{backgdcolour}{background colour index of window}{IN}
  2057. ** \param{Pint}{edgecolour}{edge colour index of window}{IN}
  2058. ** \param{Pint}{frametlcolour}{top-left frame colour index}{IN}
  2059. ** \param{Pint}{framebrcolour}{bottom-right frame colour index}{IN}
  2060. ** \param{Pint}{titlecolour}{title string colour index}{IN}
  2061. ** \param{char *}{titlestring}{title string}{IN}
  2062. ** \paramend
  2063. ** \blurb{This function creates a window structure which may be used
  2064. ** for viewing PHIGS structures, PHIGS Toolkit topology diagrams and
  2065. ** PHIGS Toolkit structure content diagrams. A terminal window
  2066. ** type which contains only text. The window size and position are
  2067. ** given in the range [0, 1]. Each window has a virtual camera
  2068. ** which is useful for moving around a scene.}
  2069. */
  2070. {
  2071.   Pint err, inclname;
  2072.   Pview_rep3 vrep;
  2073.   char stname[30], str[10];
  2074.   Ppoint textpos, iconbox, boxsize, framesize;
  2075.   Pmatrix3 unitmat, mat;
  2076.   Ppoint3 wscale, shift, boxpos;
  2077.   Pfloat charht;
  2078.   Ptext_align align;
  2079.   Pint_list incl;
  2080.    
  2081.   setwindow(windid);
  2082.   if (windptr == NULL)
  2083.   {
  2084.     if (lastwind == NULL)
  2085.     {
  2086.       firstwind = lastwind = windptr =
  2087.         (ptkswindow *)malloc(sizeof(ptkswindow));
  2088.       windptr->next = NULL;
  2089.     }
  2090.     else
  2091.     {
  2092.       lastwind->next = windptr = (ptkswindow *)malloc(sizeof(ptkswindow));
  2093.       windptr->next = NULL;
  2094.       lastwind = lastwind->next;
  2095.     }
  2096.  
  2097.     windowcount++;  
  2098.     windptr->wsid = wsid;
  2099.     checkws(wsid);
  2100.     windptr->windowid = windid;
  2101.     sprintf(stname, "ptk$window%d", windid);
  2102.     windptr->windowstid = windptr->currentstid = 
  2103.                               ptk_stringtoint("structureid", stname);
  2104.     sprintf(stname, "ptk$icon%d", windid);
  2105.     windptr->iconstid = ptk_stringtoint("structureid", stname);
  2106.     sprintf(stname, "view$window%d", windid);
  2107.     windptr->windowviewind = ptk_stringtoint("viewindex", stname);
  2108.     sprintf(stname, "name$window%d", windid);
  2109.     windptr->windowname = ptk_stringtoint("name", stname);
  2110.     windptr->windowsize = *size;
  2111.     windptr->windowposition = *position;
  2112.   
  2113.     /* default camera variables */
  2114.     windptr->position = ptk_point3(0.5, 0.5, 2.0);
  2115.     windptr->ptinterest = ptk_point3(0.5, 0.5, 0.5);
  2116.     windptr->positionaxis = ptk_point3(0.0, 1.0, 0.0);
  2117.     windptr->ptinterestaxis = ptk_point3(0.0, 1.0, 0.0);
  2118.     windptr->lastvpn = ptk_point3(0.0, 0.0, 1.0);
  2119.     windptr->lastvup = ptk_point3(0.0, 1.0, 0.0);
  2120.     windptr->swivelangle = windptr->spinangle = 
  2121.     windptr->twistangle = 0.0;
  2122.     windptr->cameraproj = PTYPE_PARAL;
  2123.     windptr->xaxis = ptk_point3(1.0, 0.0, 0.0);
  2124.     windptr->yaxis = ptk_point3(0.0, 1.0, 0.0);
  2125.   
  2126.     /* default viewing variables */
  2127.     windptr->proj_type = PTYPE_PARAL;
  2128.     windptr->vrp = ptk_point3(0.5, 0.5, 0.5);
  2129.     windptr->proj_ref_point = ptk_point3(0.0, 0.0, 2.0);
  2130.     windptr->vpn = ptk_point3(0.0, 0.0, 1.0);
  2131.     windptr->vup = ptk_point3(0.0, 1.0, 0.0);
  2132.     windptr->win = ptk_limit(-0.5, 0.5, -0.5, 0.5);
  2133.     windptr->proj_vp = ptk_limit3(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
  2134.     windptr->frontplane = 0.5;
  2135.     windptr->viewplane = 0.0;
  2136.     windptr->backplane = -0.5;
  2137.     windptr->clipxy = windptr->clipfront = windptr->clipback = PIND_NO_CLIP;
  2138.   
  2139.     /* other window defaults */
  2140.     windptr->windowtype = PTKESTRUCTWINDOW;
  2141.     windptr->cameraswitch = PTKECAMERAON;
  2142.     windptr->framesize = ptk_point(0.01, 0.01);
  2143.     windptr->iconsize = ptk_point(0.1, 0.1);
  2144.     windptr->iconposition = windptr->windowposition;
  2145.     windptr->defaulticon = TRUE;
  2146.     windptr->titlefont = 1;
  2147.     windptr->bannerheight = 0.02;
  2148.     windptr->bannercolour = backgdcolour;
  2149.   
  2150.     windptr->backgdcolour = backgdcolour;
  2151.     windptr->edgecolour = edgecolour;
  2152.     windptr->frametlcolour = frametlcolour;
  2153.     windptr->framebrcolour = framebrcolour;
  2154.     windptr->titlecolour = titlecolour;
  2155.     strncpy(windptr->titlestring, titlestring, strlen(titlestring) + 1);
  2156.     windptr->posted = FALSE;
  2157.     windptr->windowstate = PTKEWINDOWOPEN;
  2158.     windptr->viewstate = PVISUAL_ST_CORRECT;
  2159.  
  2160.     windptr->viewbox = windptr->viewlims = windptr->cliplimit =
  2161.                         ptk_limit3(position->x - (size->x / 2.0),
  2162.                                    position->x + (size->x / 2.0),
  2163.                                    position->y - (size->y / 2.0),
  2164.                                    position->y + (size->y / 2.0),
  2165.                                    0.0, 1.0);
  2166.     windptr->viewvolume = ptk_point3(1.0, 1.0, 1.0);
  2167.   
  2168.     /* make window structure */
  2169.     ptk_seteditmode(PEDIT_INSERT);
  2170.     ptk_openstruct(windptr->windowstid);
  2171.  
  2172.     incl.num_ints = 1;
  2173.     incl.ints = &inclname;
  2174.     incl.ints[0] = windptr->windowname;
  2175.     padd_names_set(&incl);
  2176.  
  2177.     plabel(ptk_stringtoint("label", "globaltran"));
  2178.     /* window frame transformation */
  2179.     shift = ptk_point3(windptr->windowposition.x, windptr->windowposition.y, 
  2180.                         0.0); 
  2181.     ptk_shift3(&shift, PTYPE_REPLACE, mat);
  2182.     pset_local_tran3(mat, PTYPE_REPLACE);
  2183.   
  2184.     plabel(ptk_stringtoint("label", "begin-frame"));
  2185.     buildframe();
  2186.     plabel(ptk_stringtoint("label", "end-frame"));
  2187.  
  2188.     pset_int_style(PSTYLE_HOLLOW);
  2189.     pset_edge_flag(PEDGE_OFF);
  2190.     pset_edge_colr_ind(1);
  2191.     pset_int_colr_ind(1);
  2192.     pset_text_colr_ind(1);
  2193.     pset_char_ht(0.01);
  2194.     pset_text_font(1);
  2195.     align.hor = PHOR_NORM;
  2196.     align.vert = PVERT_NORM;
  2197.     pset_text_align(&align);
  2198.  
  2199.     ptk_unitmatrix3(mat);
  2200.     pset_local_tran3(mat, PTYPE_REPLACE);
  2201.     pset_view_ind(windptr->windowviewind);
  2202.   
  2203.     plabel(ptk_stringtoint("label", "begin-window"));
  2204.   
  2205.     plabel(ptk_stringtoint("label", "end-window"));
  2206.     premove_names_set(&incl);
  2207.     ptk_closestruct();
  2208.   
  2209.     updatecamera();
  2210.   
  2211.     /* make default window icon structure */
  2212.     ptk_openstruct(windptr->iconstid);
  2213.     padd_names_set(&incl);
  2214.     pset_pick_id(PTKEWINDOWICON);
  2215.     shift = ptk_point3(-0.5, -0.5, 0.0);
  2216.     ptk_shift3(&shift, PTYPE_REPLACE, mat);
  2217.     wscale.x = windptr->iconsize.x;
  2218.     wscale.y = windptr->iconsize.y;
  2219.     wscale.z = 1.0;
  2220.     ptk_scale3(&wscale, PTYPE_POSTCONCAT, mat);
  2221.     shift = ptk_point3(windptr->iconposition.x, windptr->iconposition.y,
  2222.                         0.0);
  2223.     ptk_shift3(&shift, PTYPE_POSTCONCAT, mat);
  2224.     pset_local_tran3(mat, PTYPE_REPLACE);
  2225.  
  2226.     plabel(ptk_stringtoint("label", "begin-icon"));
  2227.     buildicon();
  2228.     plabel(ptk_stringtoint("label", "begin-icon-pic"));
  2229.     do_structicon();
  2230.     plabel(ptk_stringtoint("label", "end-icon"));
  2231.  
  2232.     premove_names_set(&incl); 
  2233.     ptk_closestruct(); 
  2234.     ptk_unseteditmode();
  2235.   }
  2236. }  /* createwindow */
  2237.  
  2238. /*--------------------------------------------------------------------------*/
  2239.  
  2240. /*function:external*/
  2241. extern void ptk_createwindow(C(Pint) wsid, C(Pint) windid, C(Ppoint *) size,
  2242.                              C(Ppoint *) position, C(char *) titlestring)
  2243. PreANSI(Pint wsid)
  2244. PreANSI(Pint windid)
  2245. PreANSI(Ppoint *size)
  2246. PreANSI(Ppoint *position)
  2247. PreANSI(char *titlestring)
  2248. /* 
  2249. ** \parambegin
  2250. ** \param{Pint}{wsid}{workstation identifier}{IN}
  2251. ** \param{Pint}{windid}{window identifier}{IN}
  2252. ** \param{Ppoint *}{size}{window size}{IN}
  2253. ** \param{Ppoint *}{position}{window position}{IN}
  2254. ** \param{char *}{titlestring}{title string}{IN}
  2255. ** \paramend
  2256. ** \blurb{This function creates a window structure which may be used
  2257. ** for viewing PHIGS structures, PHIGS Toolkit topology diagrams and
  2258. ** PHIGS Toolkit structure content diagrams. A terminal window
  2259. ** type which contains only text. The window size and position are
  2260. ** given in the range [0, 1]. Each window has a virtual camera
  2261. ** which is useful for moving around a scene.
  2262. ** This function requires hashtables "structureid", "label", "name",
  2263. ** "viewindex".} 
  2264. */
  2265. {
  2266.   createwindow(wsid, windid, size, position, 0, 1, 1, 1, 1, titlestring);
  2267. }  /* ptk_createwindow */
  2268.  
  2269. /*--------------------------------------------------------------------------*/
  2270.  
  2271. /*function:external*/
  2272. extern void ptk_setwindowattrs(C(Pint) windid,
  2273.       C(Pint) titlefont, C(Pint) titlecolour, C(Pint) bannercolour,
  2274.       C(Pint) backgdcolour, C(Pint) edgecolour, 
  2275.       C(Pint) frametlcolour, C(Pint) framebrcolour)
  2276. PreANSI(Pint windid)
  2277. PreANSI(Pint titlefont)
  2278. PreANSI(Pint titlecolour)
  2279. PreANSI(Pint bannercolour)
  2280. PreANSI(Pint backgdcolour)
  2281. PreANSI(Pint edgecolour)
  2282. PreANSI(Pint frametlcolour)
  2283. PreANSI(Pint framebrcolour)
  2284. /* 
  2285. ** \parambegin
  2286. ** \param{Pint}{windid}{window identifier}{IN}
  2287. ** \param{Pint}{titlefont}{title string font}{IN}
  2288. ** \param{Pint}{titlecolour}{title string colour index}{IN}
  2289. ** \param{Pint}{bannercolour}{banner colour index}{IN}
  2290. ** \param{Pint}{backgdcolour}{background colour index of window}{IN}
  2291. ** \param{Pint}{edgecolour}{edge colour index of window}{IN}
  2292. ** \param{Pint}{frametlcolour}{top-left frame colour index}{IN}
  2293. ** \param{Pint}{framebrcolour}{bottom-right frame colour index}{IN}
  2294. ** \paramend
  2295. ** \blurb{This function sets the window text font and colour attribute
  2296. ** values. Each window has a banner region which contains the title
  2297. ** string of the window. The text font value applies to this string.} 
  2298. */
  2299. {   
  2300.   setwindow(windid);
  2301.   if (windptr != NULL)
  2302.   {  
  2303.     /* other window defaults */
  2304.     windptr->titlefont = titlefont;
  2305.     windptr->titlecolour = titlecolour;  
  2306.     windptr->bannercolour = bannercolour;
  2307.     windptr->backgdcolour = backgdcolour;
  2308.     windptr->edgecolour = edgecolour;
  2309.     windptr->frametlcolour = frametlcolour;
  2310.     windptr->framebrcolour = framebrcolour;
  2311.  
  2312.     ptk_seteditmode(PEDIT_INSERT);  
  2313.     ptk_openstruct(windptr->windowstid);
  2314.     pset_elem_ptr(0);  
  2315.     /* set window frame attributes */
  2316.     pdel_elems_labels(ptk_stringtoint("label", "begin-frame"), 
  2317.                   ptk_stringtoint("label", "end-frame"));  
  2318.     buildframe();
  2319.     ptk_closestruct();
  2320.  
  2321.     ptk_openstruct(windptr->iconstid);
  2322.     pset_elem_ptr(0);  
  2323.     /* set icon frame attributes */
  2324.     pdel_elems_labels(ptk_stringtoint("label", "begin-icon"), 
  2325.                   ptk_stringtoint("label", "begin-icon-pic"));  
  2326.     buildicon();
  2327.     ptk_closestruct();
  2328.     ptk_unseteditmode();
  2329.   }
  2330. }  /* ptk_setwindowattrs */
  2331.  
  2332. /*--------------------------------------------------------------------------*/
  2333.  
  2334. /*function:external*/
  2335. extern void ptk_posttowindow(C(Pint) windid, C(Pint) id)
  2336. PreANSI(Pint windid) 
  2337. PreANSI(Pint id) 
  2338. /*
  2339. ** \parambegin
  2340. ** \param{Pint}{windid}{window identifier}{IN}
  2341. ** \param{Pint}{id}{item identifier}{IN}
  2342. ** \paramend
  2343. ** \blurb{This function posts an item to a window depending on the 
  2344. ** window type. In the case
  2345. ** of STRUCT and CONTENT windows, {\tt id} is a structure identifier.
  2346. ** For TOPOLOGY windows, {\tt id} is a topology identifier. If the window is
  2347. ** a TERMINAL window this function is ignored.}
  2348. */
  2349. {
  2350.   Pint stid, err, elptr, lstnum, fid;
  2351.   Pelem_type eltype;
  2352.   Psearch_status stat;
  2353.   ptkboolean found;
  2354.  
  2355.   setwindow(windid);
  2356.   if (windptr != NULL)
  2357.   {
  2358.     if (windptr->windowtype != PTKETERMINALWINDOW)
  2359.     {
  2360.       if (windptr->windowtype == PTKETOPOLOGYWINDOW)
  2361.         ptk_inqtopologystructid(id, &stid, &err);
  2362.       else
  2363.         stid = id;
  2364.       /* add to window structure */
  2365.       ptk_openstruct(windptr->windowstid);
  2366.       ptk_seteditmode(PEDIT_INSERT);
  2367.       pset_elem_ptr(0);
  2368.       pset_elem_ptr_label(ptk_stringtoint("label", "begin-window"));
  2369.   
  2370.       /* check if execute is already there */
  2371.       eltype = PELEM_EXEC_STRUCT;
  2372.       found = FALSE;
  2373.       do
  2374.       {
  2375.         ptk_findelemtype(&eltype, 1, PDIR_FORWARD, &stat, &elptr, &lstnum);
  2376.         if (stat == PSEARCH_STATUS_SUCCESS)
  2377.     {
  2378.           ptk_getexecuteid(windptr->windowstid, elptr, &fid);
  2379.           if (fid == stid)
  2380.             found = TRUE;
  2381.           pset_elem_ptr(elptr + 1);
  2382.         }
  2383.       } while ((!found) && (stat == PSEARCH_STATUS_SUCCESS)); 
  2384.       if (!found)
  2385.       {
  2386.         pset_elem_ptr(0);
  2387.         pset_elem_ptr_label(ptk_stringtoint("label", "begin-window"));
  2388.         pexec_struct(stid);
  2389.       }
  2390.       ptk_unseteditmode();
  2391.       ptk_closestruct();
  2392.       if (windptr->windowtype == PTKECONTENTWINDOW)
  2393.       {
  2394.         ptk_inqstructcontentrange(stid, &windptr->range1, &windptr->range2,
  2395.                                   &err);
  2396.         windptr->viewrange1 = 0;
  2397.         windptr->viewrange2 = windptr->range2;
  2398.       }
  2399.     }
  2400.   }
  2401. }  /* ptk_posttowindow */
  2402.  
  2403. /*--------------------------------------------------------------------------*/
  2404.  
  2405. /*function:external*/
  2406. extern void ptk_frontwindow(C(Pint) windid)
  2407. PreANSI(Pint windid)
  2408. /*
  2409. ** \parambegin
  2410. ** \param{Pint}{windid}{window identifier}{IN}
  2411. ** \paramend 
  2412. ** \blurb{This function sets the post priority of the window structure
  2413. ** so that it is displayed on top of all other posted windows but
  2414. ** has a lower prioity than the current back menu.}
  2415. */
  2416. {
  2417.   Pint ind, err, frontmenu, backmenu, backmenustid;
  2418.   ptkboolean menus;
  2419.  
  2420.   setwindow(windid);
  2421.   if (windptr != NULL)
  2422.   {
  2423.     findwsid(windptr->wsid, &ind);
  2424.     menus = ptk_inqfrontbackmenuid(windptr->wsid, &frontmenu, &backmenu, 
  2425.                                    &err);
  2426.     if (menus)
  2427.     {
  2428.       ptk_inqmenustructid(backmenu, &backmenustid, &err);
  2429.       ptk_postrelative(windptr->wsid, windptr->currentstid, PPRI_LOWER,
  2430.                          backmenustid, &err);
  2431.     }
  2432.     else
  2433.     if (!wswindows[ind].postedwindows)
  2434.       ppost_struct(windptr->wsid, windptr->windowstid, 0.0);
  2435.     else
  2436.       ptk_postrelative(windptr->wsid, windptr->currentstid, PPRI_HIGHER,
  2437.                        wswindows[ind].frontptr->currentstid, &err);
  2438.     if (!wswindows[ind].postedwindows)
  2439.     {
  2440.       wswindows[ind].frontptr = wswindows[ind].backptr = windptr;
  2441.       wswindows[ind].postedwindows = TRUE;
  2442.     }
  2443.     else
  2444.     {
  2445.       wswindows[ind].frontptr = windptr;
  2446.       if (windptr->currentstid == wswindows[ind].backptr->currentstid)
  2447.         findback(windptr->wsid, &wswindows[ind]);
  2448.     }
  2449.     windptr->posted = TRUE;
  2450.   }
  2451. }  /* ptk_frontwindow */
  2452.  
  2453. /*--------------------------------------------------------------------------*/
  2454.  
  2455. /*function:external*/
  2456. extern void ptk_backwindow(C(Pint) windid)
  2457. PreANSI(Pint windid)
  2458. /*
  2459. ** \parambegin
  2460. ** \param{Pint}{windid}{window identifier}{IN}
  2461. ** \paramend 
  2462. ** \blurb{This function sets the post priority of a window structure
  2463. ** so that it is displayed behind all the other posted windows and menus.}
  2464. */
  2465. {
  2466.   Pint ind, err, frontmenu, backmenu, backmenustid;
  2467.   ptkboolean menus;
  2468.  
  2469.   setwindow(windid);
  2470.   if (windptr != NULL)
  2471.   {
  2472.     findwsid(windptr->wsid, &ind);
  2473.     menus = ptk_inqfrontbackmenuid(windptr->wsid, &frontmenu, &backmenu,
  2474.                                    &err);
  2475.     if (!wswindows[ind].postedwindows)
  2476.     {
  2477.       if (menus)
  2478.       {
  2479.         ptk_inqmenustructid(backmenu, &backmenustid, &err);
  2480.         ptk_postrelative(windptr->wsid, windptr->currentstid, PPRI_LOWER,
  2481.                          backmenustid, &err);
  2482.       }
  2483.       else
  2484.         ppost_struct(windptr->wsid, windptr->currentstid, 0.0);
  2485.       wswindows[ind].frontptr = wswindows[ind].backptr = windptr;
  2486.       wswindows[ind].postedwindows = TRUE;
  2487.     }
  2488.     else
  2489.     {
  2490.       ptk_postrelative(windptr->wsid, windptr->currentstid, PPRI_LOWER,
  2491.                        wswindows[ind].backptr->currentstid, &err);
  2492.       wswindows[ind].backptr = windptr;
  2493.       if (windptr == wswindows[ind].frontptr)
  2494.         findfront(windptr->wsid, &wswindows[ind]);
  2495.     }
  2496.     windptr->posted = TRUE;
  2497.   }
  2498. }  /* ptk_backwindow */
  2499.  
  2500. /*--------------------------------------------------------------------------*/
  2501.  
  2502. /*function:external*/
  2503. extern void ptk_unpostfromwindow(C(Pint) windid, C(Pint) id)
  2504. PreANSI(Pint windid) 
  2505. PreANSI(Pint id) 
  2506. /*
  2507. ** \parambegin
  2508. ** \param{Pint}{windid}{window identifier}{IN}
  2509. ** \param{Pint}{id}{item identifier}{IN}
  2510. ** \paramend
  2511. ** \blurb{This function unposts an item from a window depending on the
  2512. ** window type. In the case
  2513. ** of STRUCT and CONTENT windows, id is a structure identifier.
  2514. ** For TOPOLOGY windows, id is a topology identifier. If the window is
  2515. ** a TERMINAL window this function is ignored.}
  2516. */
  2517. {
  2518.   Pint stid, elptr, lstnum, err, fid;
  2519.   Pelem_type eltype;
  2520.   Psearch_status stat;
  2521.   ptkboolean found;
  2522.  
  2523.   setwindow(windid);
  2524.   if (windptr != NULL)
  2525.   {
  2526.     if (windptr->windowtype != PTKETERMINALWINDOW)
  2527.     {
  2528.       if (windptr->windowtype == PTKETOPOLOGYWINDOW)
  2529.         ptk_inqtopologystructid(id, &stid, &err);
  2530.       else
  2531.         stid = id;
  2532.       /* add to window structure */
  2533.       ptk_openstruct(windptr->windowstid);
  2534.       ptk_seteditmode(PEDIT_INSERT);
  2535.       pset_elem_ptr(0);
  2536.       pset_elem_ptr_label(ptk_stringtoint("label", "begin-window"));
  2537.   
  2538.       /* check if execute is already there */
  2539.       eltype = PELEM_EXEC_STRUCT;
  2540.       found = FALSE;
  2541.       do
  2542.       {
  2543.         ptk_findelemtype(&eltype, 1, PDIR_FORWARD, &stat, &elptr, &lstnum);
  2544.         if (stat == PSEARCH_STATUS_SUCCESS)
  2545.     {
  2546.           ptk_getexecuteid(windptr->windowstid, elptr, &fid);
  2547.           if (fid == stid)
  2548.             found = TRUE;
  2549.           pset_elem_ptr(elptr + 1);
  2550.         }
  2551.       } while ((!found) && (stat == PSEARCH_STATUS_SUCCESS));
  2552.       if (found)
  2553.       {
  2554.         pset_elem_ptr(elptr);
  2555.         pdel_elem();
  2556.       }
  2557.       ptk_unseteditmode();
  2558.       ptk_closestruct();
  2559.     }
  2560.   }
  2561. }  /* ptk_unpostfromwindow */
  2562.  
  2563. /*--------------------------------------------------------------------------*/
  2564.  
  2565. /*function:external*/
  2566. extern void ptk_unpostallfromwindow(C(Pint) windid)
  2567. PreANSI(Pint windid)
  2568. /*
  2569. ** \parambegin
  2570. ** \param{Pint}{windid}{window identifier}{IN}
  2571. ** \paramend 
  2572. ** \blurb{This function unposts all items posted to window {\tt windid}.
  2573. ** If the window is a TERMINAL window this function is ignored.}
  2574. */
  2575. {
  2576.   Pint label1, label2;
  2577.  
  2578.   setwindow(windid);
  2579.   if (windptr != NULL)
  2580.   {
  2581.     if (windptr->windowtype != PTKETERMINALWINDOW)
  2582.     {
  2583.       ptk_openstruct(windptr->windowstid);
  2584.       /* Implementation dependent code
  2585.       ** because of problem with delelemslabels in SunPHIGS
  2586.       */
  2587. #ifdef SUN
  2588.       pset_elem_ptr(0);
  2589.       ptk_findlabel(ptk_stringtoint("label", "begin-window"), &label1);
  2590.       pset_elem_ptr(0);
  2591.       ptk_findlabel(ptk_stringtoint("label", "end-window"), &label2);
  2592.       if ((label2 - label1) > 1)
  2593.       {
  2594.         if ((label2 - label1) == 2)
  2595.     {
  2596.           pset_elem_ptr(0);
  2597.           pset_elem_ptr(label1);
  2598.           poffset_elem_ptr(1);
  2599.           pdel_elem();
  2600.         }
  2601.         else
  2602.           pdel_elem_range(label1 + 1, label2 - 1);
  2603.       }
  2604. #endif
  2605. #ifndef SUN
  2606.       /* do for HP and PEXSI */
  2607.       pset_elem_ptr(0);
  2608.       pdel_elems_labels(ptk_stringtoint("label", "begin-window"),
  2609.             ptk_stringtoint("label", "end-window"));
  2610. #endif
  2611.       ptk_closestruct();
  2612.     }
  2613.   }
  2614. }  /* ptk_unpostallfromwindow */
  2615.  
  2616. /*--------------------------------------------------------------------------*/
  2617.  
  2618. /*function:external*/
  2619. extern void ptk_postwindow(C(Pint) windid)
  2620. PreANSI(Pint windid) 
  2621. /*
  2622. ** \parambegin
  2623. ** \param{Pint}{windid}{window identifier}{IN}
  2624. ** \paramend
  2625. ** \blurb{This function posts a window structure to the workstation
  2626. ** specified when the window was initially created. Windows are bound
  2627. ** to workstation because they each use one view table entry to
  2628. ** define the window view. The priority of the window structure is
  2629. ** controlled by the PHIGS Toolkit window system to provide an ordered
  2630. ** stacking mechanism for windows.}
  2631. */
  2632. {
  2633.   ptk_frontwindow(windid);
  2634. }  /* ptk_postwindow */
  2635.  
  2636. /*--------------------------------------------------------------------------*/
  2637.  
  2638. /*function:external*/
  2639. extern void ptk_unpostwindow(C(Pint) windid)
  2640. PreANSI(Pint windid) 
  2641. /*
  2642. ** \parambegin
  2643. ** \param{Pint}{windid}{window identifier}{IN}
  2644. ** \paramend
  2645. ** \blurb{This function unposts a window from the workstation it is
  2646. ** bound to.}
  2647. */
  2648. {
  2649.   Pint ind;
  2650.  
  2651.   setwindow(windid);
  2652.   if (windptr != NULL)
  2653.   {
  2654.     punpost_struct(windptr->wsid, windptr->currentstid);
  2655.     findwsid(windptr->wsid, &ind);
  2656.     if (windptr == wswindows[ind].backptr)
  2657.       findback(windptr->wsid, &wswindows[ind]);
  2658.     if (windptr == wswindows[ind].frontptr)
  2659.       findfront(windptr->wsid, &wswindows[ind]);
  2660.     windptr->posted = FALSE;
  2661.   }
  2662. }  /* ptk_unpostwindow */
  2663.  
  2664. /*--------------------------------------------------------------------------*/
  2665.  
  2666. /*function:external*/
  2667. extern ptkboolean ptk_delwindow(C(Pint) windid)
  2668. PreANSI(Pint windid) 
  2669. /*
  2670. ** \parambegin
  2671. ** \param{Pint}{windid}{window identifier}{IN}
  2672. ** \paramend
  2673. ** \blurb{This function deletes a window from the PHIGS Toolkit window
  2674. ** store.}
  2675. */
  2676. {
  2677.   ptkswindow *ptr, *junk;
  2678.   char stname[20];
  2679.  
  2680.   ptk_unpostwindow(windid);
  2681.   ptr = firstwind;
  2682.   if (ptr->windowid == windid)
  2683.   {
  2684.     firstwind = firstwind->next;
  2685.     if (lastwind->windowid == windid)
  2686.       lastwind = firstwind;
  2687.     pdel_struct(ptr->windowstid);
  2688.     pdel_struct(ptr->iconstid);
  2689.     if (ptr->windowtype == PTKETERMINALWINDOW)
  2690.     {
  2691.       pdel_struct(ptr->term.textstid);
  2692.       sprintf(stname, "ptk$term%d", windid);
  2693.       ptk_delstring("structureid", stname);
  2694.     }
  2695.     free(ptr);
  2696.   }
  2697.   else
  2698.   {
  2699.     while (ptr->next->windowid != windid)
  2700.     {
  2701.       ptr = ptr->next;
  2702.       if (ptr->next == NULL)
  2703.         return FALSE;
  2704.     }
  2705.     junk = ptr->next;
  2706.     ptr->next = junk->next;
  2707.     pdel_struct(junk->windowstid);
  2708.     pdel_struct(junk->iconstid);
  2709.     if (ptr->windowtype == PTKETERMINALWINDOW)
  2710.     {
  2711.       pdel_struct(junk->term.textstid);
  2712.       sprintf(stname, "ptk$term%d", windid);
  2713.       ptk_delstring("structureid", stname);
  2714.     }
  2715.     free(junk);
  2716.     if (ptr->next == NULL)
  2717.       lastwind = ptr;
  2718.   }
  2719.  
  2720.   /* delete strings */
  2721.   sprintf(stname, "ptk$window%d", windid);
  2722.   ptk_delstring("structureid", stname);
  2723.   sprintf(stname, "ptk$icon%d", windid);
  2724.   ptk_delstring("structureid", stname);
  2725.   sprintf(stname, "view$window%d", windid);
  2726.   ptk_delstring("viewindex", stname);
  2727.   sprintf(stname, "name$window%d", windid);
  2728.   ptk_delstring("name", stname);
  2729.   windowcount--;
  2730.   return TRUE;
  2731. }  /* ptk_delwindow */
  2732.  
  2733. /*--------------------------------------------------------------------------*/
  2734.  
  2735. /*function:external*/
  2736. extern void ptk_openwindow(C(Pint) windid)
  2737. PreANSI(Pint windid)
  2738. /*
  2739. ** \parambegin
  2740. ** \param{Pint}{windid}{window identifier}{IN}
  2741. ** \paramend 
  2742. ** \blurb{This function posts the window structure and unposts the icon
  2743. ** structure from the window's workstation.}
  2744. */
  2745. {
  2746.   Pfloat priority;
  2747.   Pint err;
  2748.  
  2749.   setwindow(windid);
  2750.   if (windptr != NULL)
  2751.   {
  2752.     if (windptr->windowstate == PTKEWINDOWCLOSED)
  2753.     {
  2754.       ptk_inqpostpriority(windptr->wsid, windptr->iconstid, &priority, &err);
  2755.       punpost_struct(windptr->wsid, windptr->iconstid);
  2756.       ppost_struct(windptr->wsid, windptr->windowstid, priority);
  2757.       windptr->windowstate = PTKEWINDOWOPEN;
  2758.       windptr->currentstid = windptr->windowstid;
  2759.       if (windptr->viewstate == PVISUAL_ST_DEFER)
  2760.       {
  2761.         updatewindowview();
  2762.         windptr->viewstate = PVISUAL_ST_CORRECT;
  2763.       }
  2764.     }
  2765.   }
  2766. }  /* ptk_openwindow */
  2767.  
  2768. /*--------------------------------------------------------------------------*/
  2769.  
  2770. /*function:external*/
  2771. extern void ptk_closewindow(C(Pint) windid)
  2772. PreANSI(Pint windid)
  2773. /*
  2774. ** \parambegin
  2775. ** \param{Pint}{windid}{window identifier}{IN}
  2776. ** \paramend 
  2777. ** \blurb{This function posts the icon structure and unposts the window
  2778. ** structure from the window's workstation.}
  2779. */
  2780. {
  2781.   Pfloat priority;
  2782.   Pint err;
  2783.  
  2784.   setwindow(windid);
  2785.   if (windptr != NULL)
  2786.   {
  2787.     if (windptr->windowstate == PTKEWINDOWOPEN)
  2788.     {
  2789.       ptk_inqpostpriority(windptr->wsid, windptr->windowstid, &priority, 
  2790.                           &err);
  2791.       punpost_struct(windptr->wsid, windptr->windowstid);
  2792.       ppost_struct(windptr->wsid, windptr->iconstid, priority);
  2793.       windptr->windowstate = PTKEWINDOWCLOSED;
  2794.       windptr->currentstid = windptr->iconstid;
  2795.     }
  2796.   }
  2797. }  /* ptk_closewindow */
  2798.  
  2799. /*--------------------------------------------------------------------------*/
  2800.  
  2801. /*function:external*/
  2802. extern void ptk_setwindowposition(C(Pint) windid, C(Ppoint *) position)
  2803. PreANSI(Pint windid)
  2804. PreANSI(Ppoint *position)
  2805. /*
  2806. ** \parambegin
  2807. ** \param{Pint}{windid}{window identifier}{IN}
  2808. ** \param{Ppoint *}{position}{window position}{IN}
  2809. ** \paramend 
  2810. ** \blurb{This function sets the position of the centre of the window.
  2811. ** The position is given in the range [0, 1]. If the position results
  2812. ** in part of the window being clipped then the position is adjusted
  2813. ** so that the whole window is visible.}
  2814. */
  2815. { 
  2816.   setwindow(windid);
  2817.   if (windptr != NULL)
  2818.   {
  2819.     windptr->windowposition = *position;
  2820.     setvalidwindowpos();
  2821.     updateframe();
  2822.     if (windptr->windowtype == PTKESTRUCTWINDOW)
  2823.       adjustlimits(&windptr->viewvolume); 
  2824.     if (windptr->windowtype == PTKETERMINALWINDOW)
  2825.       windptr->proj_vp = windptr->cliplimit = windptr->viewlims;
  2826.     if (windptr->windowtype == PTKECONTENTWINDOW)
  2827.       ptk_setcontentviewrange(windid, windptr->viewrange1, 
  2828.                               windptr->viewrange2);
  2829.     else
  2830.       updatewindowview();
  2831.   }
  2832. }  /* ptk_setwindowposition */
  2833.  
  2834. /*--------------------------------------------------------------------------*/
  2835.  
  2836. /*function:external*/
  2837. extern void ptk_setwindowsize(C(Pint) windid, C(Ppoint *) size)
  2838. PreANSI(Pint windid)
  2839. PreANSI(Ppoint *size)
  2840. /*
  2841. ** \parambegin
  2842. ** \param{Pint}{windid}{window identifier}{IN}
  2843. ** \param{Ppoint *}{size}{window size}{IN}
  2844. ** \paramend 
  2845. ** \blurb{This function sets the size of the window using the x value
  2846. ** as the width and the y value as the height. The values are given
  2847. ** in the range [0, 1]. If the size results in part of the window
  2848. ** being clipped then the window size is adjusted to give as large a
  2849. ** window as possible.}
  2850. */
  2851. {
  2852.   Pfloat height, extraspace, textspace, oldlinesize;
  2853.   Pfloat newlinesize, newlines;
  2854.   Ppoint oldsize;
  2855.  
  2856.   setwindow(windid);
  2857.   if (windptr != NULL)
  2858.   {
  2859.     oldsize = windptr->windowsize;
  2860.     windptr->windowsize = *size;
  2861.     setvalidwindowsize();
  2862.     switch (windptr->windowtype)
  2863.     {
  2864.       case PTKESTRUCTWINDOW:
  2865.         updateframe();
  2866.         adjustlimits(&windptr->viewvolume);
  2867.         updatewindowview();
  2868.         break;
  2869.  
  2870.       case PTKETERMINALWINDOW:
  2871.         windptr->term.realcols *= (windptr->windowsize.x / oldsize.x); 
  2872.         windptr->term.columns = windptr->term.curr_colm = 
  2873.                                   (Pint)windptr->term.realcols;
  2874.         height = windptr->windowsize.y / oldsize.y;
  2875.         oldlinesize = oldsize.y/(Pfloat)windptr->term.lines;
  2876.         windptr->term.reallines *= height;
  2877.         newlines = (Pfloat)floor(windptr->term.reallines);
  2878.         extraspace = windptr->windowsize.y - (oldsize.y * 
  2879.                                 (newlines / (Pfloat)windptr->term.lines));
  2880.         windptr->term.lines = (Pint)windptr->term.reallines;
  2881.         windptr->term.increment += extraspace/newlines;
  2882.         newlinesize = size->y/(Pfloat)windptr->term.lines; 
  2883.         textspace = (Pfloat)windptr->term.curr_line * oldlinesize;
  2884.         windptr->term.curr_line = (Pint)((Pfloat)textspace / newlinesize) + 1;
  2885.         updateframe();
  2886.         initialiseterminal();
  2887.         break;
  2888.  
  2889.       case PTKECONTENTWINDOW:
  2890.         updateframe();
  2891.         ptk_setcontentviewrange(windid, windptr->viewrange1, 
  2892.                                 windptr->viewrange2);
  2893.         break;
  2894.  
  2895.       case PTKETOPOLOGYWINDOW:
  2896.         updateframe();
  2897.         ptk_settopologyviewarea(windid, &windptr->topviewarea);
  2898.         break;
  2899.     }
  2900.   }
  2901. }  /* ptk_setwindowsize */
  2902.  
  2903. /*--------------------------------------------------------------------------*/
  2904.  
  2905. /*function:external*/
  2906. extern void ptk_setwindowtraninputpri(C(Pint) windid, C(Pint) refwindid, 
  2907.                                       C(Prel_pri) priority)
  2908. PreANSI(Pint windid)
  2909. PreANSI(Pint refwindid)
  2910. PreANSI(Prel_pri priority)
  2911. /*
  2912. ** \parambegin
  2913. ** \param{Pint}{windid}{window identifier}{IN}
  2914. ** \param{Pint}{refwindid}{reference window identifier}{IN}
  2915. ** \param{Prel\_pri}{priority}{relative priority}{IN}
  2916. ** \paramend 
  2917. ** \blurb{This function sets the transformation input priority of the 
  2918. ** window's view representation relative to another window.
  2919. ** The relative priority is also set relative to view index 0.}
  2920. */
  2921. {
  2922.   Pint refindex;
  2923.   ptkswindow *ptrwindow;
  2924.  
  2925.   setwindow(windid);
  2926.   if (windptr != NULL)
  2927.   {
  2928.     if (iswindow(refwindid, &ptrwindow))
  2929.     {
  2930.       refindex = ptrwindow->windowviewind;
  2931.       pset_view_tran_in_pri(windptr->wsid, windptr->windowviewind, refindex,
  2932.                            priority);
  2933.     }
  2934.     pset_view_tran_in_pri(windptr->wsid, windptr->windowviewind, 0,
  2935.                          priority);
  2936.   }
  2937. }  /* ptk_setwindowtraninputpri */
  2938.  
  2939. /*--------------------------------------------------------------------------*/
  2940.  
  2941. /*function:external*/
  2942. extern void ptk_setframesize(C(Pint) windid, C(Ppoint *) size)
  2943. PreANSI(Pint windid)
  2944. PreANSI(Ppoint *size)
  2945. /*
  2946. ** \parambegin
  2947. ** \param{Pint}{windid}{window identifier}{IN}
  2948. ** \param{Ppoint *}{size}{frame size}{IN}
  2949. ** \paramend 
  2950. ** \blurb{This function sets the thickness of the window frame. The
  2951. ** x and y dimensions are given in the range [0, 1].}
  2952. */
  2953. {
  2954.   setwindow(windid);
  2955.   if (windptr != NULL)
  2956.   {
  2957.     if ((size->x > 0.0) && (size->y > 0.0))
  2958.     {  
  2959.       windptr->framesize = *size;
  2960.       updateframe();
  2961.     }
  2962.   }
  2963. }  /* ptk_setframesize */
  2964.  
  2965. /*--------------------------------------------------------------------------*/
  2966.  
  2967. /*function:external*/
  2968. extern ptkboolean ptk_stringscanwindows(C(Pint) wsid, C(char *) str, 
  2969.                                 C(Pint *) windowid)
  2970. PreANSI(Pint wsid)
  2971. PreANSI(char *str)
  2972. PreANSI(Pint *windowid)
  2973. /*
  2974. ** \parambegin
  2975. ** \param{Pint}{wsid}{workstation identifier}{IN}
  2976. ** \param{char *}{str}{string}{IN}
  2977. ** \param{Pint *}{windowid}{window identifier}{OUT}
  2978. ** \paramend
  2979. ** \blurb{This function compares the character string {\tt str} with
  2980. ** title string of all the windows posted to workstation {\tt wsid}.
  2981. ** The string comparison is case sensitive and begins with the
  2982. ** front window and works back to the lowest priority window.
  2983. ** The function returns TRUE if a match is found, otherwise FALSE.}
  2984. */
  2985. {
  2986.   ptkboolean windowfound;
  2987.   Pint_list *windows;
  2988.   ptkswindow *ptrwindow;
  2989.   Pint numstructs, i, err;
  2990.   Pposted_struct_list structlist;
  2991.   Pfilter *invisfilt;
  2992.   Pstore store;
  2993.  
  2994.   windowfound = FALSE;
  2995.   structlist.postings = NULL;
  2996.   pinq_posted_structs(wsid, 0, 0, &err, &structlist, &numstructs);
  2997.   structlist.postings = (Pposted_struct *)calloc(numstructs, 
  2998.                                               sizeof(Pposted_struct));
  2999.   pinq_posted_structs(wsid, numstructs, 0, &err, &structlist, &numstructs);
  3000.  
  3001.   /* inquire invisibility filter */
  3002.   pcreate_store(&err, &store);
  3003.   pinq_invis_filter(wsid, store, &err, &invisfilt);
  3004.  
  3005.   /* This bit is a bit dodgy because it relies on structlist being ordered
  3006.   ** by PHIGS into highest priority last. This is not standard PHIGS,
  3007.   ** so if version is not sorted do a sort.
  3008.   */
  3009.   i = numstructs - 1;
  3010.   while ((i >= 0) && (!windowfound)) 
  3011.   {
  3012.     if (iswindow(structlist.postings[i].id, &ptrwindow))
  3013.     {
  3014.       /* check invisibility filter */
  3015.       if (!((inintlst(ptrwindow->windowname, &invisfilt->incl_set) != -1) && 
  3016.           (inintlst(ptrwindow->windowname, &invisfilt->excl_set) == -1)))
  3017.       {
  3018.         if (find_string(ptrwindow->currentstid, str))
  3019.         {
  3020.           windowfound = TRUE;
  3021.           *windowid = ptrwindow->windowid;
  3022.         }
  3023.       }
  3024.     }
  3025.     i--;
  3026.   }
  3027.   ptk_delstore(store);
  3028.   free(structlist.postings);
  3029.   return windowfound;
  3030. }  /* ptk_stringscanwindows */
  3031.  
  3032. /*--------------------------------------------------------------------------*/
  3033.  
  3034. /*function:external*/
  3035. extern ptkboolean ptk_pickscanwindows(C(Ppick_path *) pickpath, 
  3036.   C(Ppath_order) pathorder, C(Pint *) windowid, C(ptkewindowarea *) windowarea)
  3037. PreANSI(Ppick_path *pickpath)
  3038. PreANSI(Ppath_order pathorder)
  3039. PreANSI(Pint *windowid)
  3040. PreANSI(ptkewindowarea *windowarea)
  3041. /*
  3042. ** \parambegin
  3043. ** \param{Ppick\_path *}{pickpath}{path through structure network}{IN}
  3044. ** \param{Ppath\_order}{pathorder}{order of path through network}{IN}
  3045. ** \param{Pint *}{windowid}{window identifier}{OUT}
  3046. ** \paramend
  3047. ** \blurb{This function tests the pick path to inquire if a window 
  3048. ** structure was picked. The window area picked may be one of
  3049. ** BANNER, VIEW, FRAME or ICON. The function
  3050. ** returns TRUE if a window was picked, otherwise FALSE.}
  3051. */
  3052. {
  3053.   Pint windowstid;
  3054.  
  3055.   if (pathorder == PORDER_TOP_FIRST)
  3056.   {
  3057.     *windowarea = pickpath->path_list[pickpath->depth - 1].pick_id;
  3058.     windowstid = pickpath->path_list[0].struct_id;
  3059.     return (getwindowid(windowstid, windowid));
  3060.   }
  3061.   else
  3062.   {
  3063.     *windowarea = pickpath->path_list[0].pick_id;
  3064.     windowstid = pickpath->path_list[pickpath->depth - 1].struct_id;
  3065.     return (getwindowid(windowstid, windowid));
  3066.   }
  3067. }  /* ptk_pickscanwindows */
  3068.  
  3069. /*--------------------------------------------------------------------------*/
  3070.  
  3071. /*function:external*/
  3072. extern ptkboolean ptk_locscanwindows(C(Pint) wsid, C(Ppoint *) point, 
  3073.         C(Pint *) windowid, C(ptkewindowarea *) windowarea, C(Ppoint *) value)
  3074. PreANSI(Pint wsid)
  3075. PreANSI(Ppoint *point)
  3076. PreANSI(Pint *windowid)
  3077. PreANSI(ptkewindowarea *windowarea)
  3078. PreANSI(Ppoint *value)
  3079. /*
  3080. ** \parambegin
  3081. ** \param{Pint}{wsid}{workstation identifier}{IN}
  3082. ** \param{Ppoint *}{point}{input point}{IN}
  3083. ** \param{Pint *}{windowid}{window identifier}{OUT}
  3084. ** \param{ptkewindowarea *}{windowarea}{window area}{OUT}
  3085. ** \param{Ppoint *}{value}{position of point within window area}{OUT}
  3086. ** \paramend
  3087. ** \blurb{This function uses the INCREMENTAL SPATIAL SEARCH function 
  3088. ** of PHIGS to test if {\tt point} lies within a window
  3089. ** posted to workstation {\tt wsid}. The window area (one of
  3090. ** BANNER, VIEW, FRAME or ICON) and the position of {\tt point} relative
  3091. ** to the bottom-left corner of the bounding box of the window area are
  3092. ** returned in {\tt windowarea} and {\tt value}.
  3093. ** The function returns TRUE if {\tt point} lies within a window,
  3094. ** otherwise FALSE.}
  3095. */
  3096. {
  3097.   ptkboolean windowfound;
  3098.   ptkswindow *ptrwindow;
  3099.   Plimit3 windowbox, area;
  3100.   Pint numstructs, i, err;
  3101.   Pposted_struct_list structlist;
  3102.   Pint lstnum, stopelem;
  3103.   Pelem_type eltype;
  3104.   Psearch_status stat;
  3105.   Pfloat div;
  3106.   Pfilter *invisfilt;
  3107.   Pstore store;
  3108.  
  3109.   ptk_stacktsl();
  3110.   ptk_stackbbox();
  3111.   eltype = PELEM_VIEW_IND;
  3112.   windowfound = FALSE;
  3113.   structlist.postings = NULL;
  3114.   pinq_posted_structs(wsid, 0, 0, &err, &structlist, &numstructs);
  3115.   structlist.postings = (Pposted_struct *)calloc(numstructs, 
  3116.                                               sizeof(Pposted_struct));
  3117.   pinq_posted_structs(wsid, numstructs, 0, &err, &structlist, &numstructs);
  3118.  
  3119.   /* inquire invisibility filter */
  3120.   pcreate_store(&err, &store);
  3121.   pinq_invis_filter(wsid, store, &err, &invisfilt);
  3122.  
  3123.   /* This bit is a bit dodgy because it relies on structlist being ordered
  3124.   ** by PHIGS into highest priority last. This is not standard PHIGS,
  3125.   ** so if version is not sorted do a sort.
  3126.   ** HP orders with highest priority first.
  3127.   */
  3128. #ifndef HP
  3129.   /* do for SUN and PEXSI */
  3130.   i = numstructs - 1;
  3131.   while ((i >= 0) && (!windowfound)) 
  3132. #endif
  3133. #ifdef HP
  3134.   i = 0;
  3135.   while ((i < numstructs) && (!windowfound)) 
  3136. #endif
  3137.   {
  3138.     if (iswindow(structlist.postings[i].id, &ptrwindow))
  3139.     {
  3140.       /* check invisibility filter */
  3141.       if (!((inintlst(ptrwindow->windowname, &invisfilt->incl_set) != -1) && 
  3142.           (inintlst(ptrwindow->windowname, &invisfilt->excl_set) == -1)))
  3143.       {
  3144.         if (ptrwindow->windowstate == PTKEWINDOWOPEN)
  3145.     {
  3146.           ptk_openstruct(ptrwindow->currentstid);
  3147.           pset_elem_ptr(0);
  3148.           ptk_findelemtype(&eltype, 1, PDIR_FORWARD, &stat, &stopelem, &lstnum);
  3149.           ptk_closestruct();
  3150.           ptk_inittsl();
  3151.           ptk_tsltraverserange(ptrwindow->currentstid, 1, 
  3152.                                ptrwindow->currentstid, stopelem, TRUE);
  3153.           ptk_inqboundingbox(&windowbox);
  3154.         }
  3155.         else
  3156.           ptk_boundingbox(ptrwindow->currentstid, &windowbox, TRUE);
  3157.         if (ptinlimit3(point, &windowbox))
  3158.         {
  3159.           windowfound = TRUE;
  3160.           *windowid = ptrwindow->windowid;
  3161.           *value = ptk_point(0.0, 0.0);
  3162.         }
  3163.       }
  3164.     }
  3165.     if (!windowfound)
  3166. #ifndef HP
  3167.       /* do for SUN and PEXSI */
  3168.       i--;
  3169. #endif
  3170. #ifdef HP
  3171.       i++;
  3172. #endif
  3173.   }
  3174.   if (windowfound)
  3175.   {
  3176.     if (ptrwindow->windowstate == PTKEWINDOWCLOSED)
  3177.     {
  3178.       *windowarea = PTKEWINDOWICON;
  3179.       ptk_boundingbox(ptrwindow->iconstid, &area, TRUE);
  3180.     }
  3181.     else
  3182.     {
  3183.       area = ptk_limit3(ptrwindow->windowposition.x - 
  3184.                     (ptrwindow->windowsize.x / 2.0),
  3185.                     ptrwindow->windowposition.x + 
  3186.                     (ptrwindow->windowsize.x / 2.0),
  3187.                     ptrwindow->windowposition.y - 
  3188.                     (ptrwindow->windowsize.y / 2.0),
  3189.                     ptrwindow->windowposition.y + 
  3190.                     (ptrwindow->windowsize.y / 2.0), 0.0, 0.0);
  3191.       if (ptinlimit3(point, &area))
  3192.         *windowarea = PTKEWINDOWVIEW;
  3193.       else
  3194.       {
  3195.         area.y_min = area.y_max;
  3196.         area.y_max += ptrwindow->bannerheight;
  3197.         if (ptinlimit3(point, &area))
  3198.           *windowarea = PTKEWINDOWBANNER;
  3199.         else
  3200.     {
  3201.           *windowarea = PTKEWINDOWFRAME;
  3202. /*#ifdef HP
  3203.           area = windowbox;
  3204. #endif
  3205. #ifdef SUN
  3206. */
  3207.           ptk_openstruct(ptrwindow->currentstid);
  3208.           pset_elem_ptr(0);
  3209.           ptk_findelemtype(&eltype, 1, PDIR_FORWARD, &stat, &stopelem, &lstnum);
  3210.           ptk_closestruct();
  3211.           ptk_inittsl();
  3212.           ptk_tsltraverserange(ptrwindow->currentstid, 1, 
  3213.                                ptrwindow->currentstid, stopelem, TRUE);
  3214.           ptk_inqboundingbox(&area);
  3215. /*
  3216. #endif
  3217. */
  3218.         }
  3219.       }
  3220.     }
  3221.     div = area.x_max - area.x_min;
  3222.     if (div != 0.0)
  3223.       value->x = (point->x - area.x_min)/div;
  3224.     div = area.y_max - area.y_min;
  3225.     if (div != 0.0)
  3226.       value->y = (point->y - area.y_min)/div;
  3227.   }
  3228.   ptk_delstore(store);
  3229.   free(structlist.postings);
  3230.   ptk_unstackbbox();
  3231.   ptk_unstacktsl();
  3232.   return windowfound; 
  3233. }  /* ptk_locscanwindows */
  3234.  
  3235. /*--------------------------------------------------------------------------*/
  3236.  
  3237. /*function:external*/
  3238. extern ptkboolean ptk_scanwindows(C(Pint) wsid, C(ptksgeneralinput *) input, 
  3239.                                C(ptkswindowoutput *) output)
  3240. PreANSI(Pint wsid)
  3241. PreANSI(ptksgeneralinput *input)
  3242. PreANSI(ptkswindowoutput *output)
  3243. /*
  3244. ** \parambegin
  3245. ** \param{Pint}{wsid}{workstation identifier}{IN}
  3246. ** \param{ptksgeneralinput *}{input}{input data}{IN}
  3247. ** \param{ptkswindowoutput *}{output}{output data}{IN}
  3248. ** \paramend
  3249. ** \blurb{This function performs a scan on all posted windows using
  3250. ** either string, pick or locator data.
  3251. ** The function returns TRUE if a window has been selected, 
  3252. ** otherwise FALSE.}
  3253. */
  3254. {
  3255.   ptkboolean result;
  3256.  
  3257.   switch (input->inputclass) 
  3258.   {
  3259.  
  3260.   case PIN_LOC:
  3261.     result = ptk_locscanwindows(wsid, &input->ptkugeninput.locpoint, &output->windowid, &output->windowarea, &output->value);
  3262.     output->measure = TRUE;
  3263.     break;
  3264.  
  3265.   case PIN_STROKE:
  3266.     result = FALSE;
  3267.     break;
  3268.  
  3269.   case PIN_VAL:
  3270.     result = FALSE;
  3271.     break;
  3272.  
  3273.   case PIN_CHOICE:
  3274.     result = FALSE;
  3275.     break;
  3276.  
  3277.   case PIN_PICK:
  3278.     result = ptk_pickscanwindows(&input->ptkugeninput.ptkspickinput.pickdata, 
  3279.                           input->ptkugeninput.ptkspickinput.pathorder,
  3280.                           &output->windowid, &output->windowarea);
  3281.     output->measure = FALSE;
  3282.     break;
  3283.  
  3284.   case PIN_STRING:
  3285.     result = ptk_stringscanwindows(wsid, input->ptkugeninput.str, 
  3286.                                    &output->windowid);
  3287.     output->measure = FALSE;
  3288.     output->windowarea = PTKEWINDOWBANNER;
  3289.     break;
  3290.   }
  3291.   return result;
  3292. }  /* ptk_scanwindows */
  3293.  
  3294. /*--------------------------------------------------------------------------*/
  3295.  
  3296. /*function:external*/
  3297. extern void ptk_inqpostedwindows(C(Pint) wsid, C(Pint) size, 
  3298.                              C(Pint_list *) windowids, C(Pint *) totalsize,
  3299.                              C(Pint *) err)
  3300. PreANSI(Pint wsid)
  3301. PreANSI(Pint size)
  3302. PreANSI(Pint_list *windowids)
  3303. PreANSI(Pint *totalsize)
  3304. PreANSI(Pint *err)
  3305. /*
  3306. ** \parambegin
  3307. ** \param{Pint}{wsid}{workstation identifier}{IN}
  3308. ** \param{Pint}{size}{size of buffer}{IN}
  3309. ** \param{Pint\_list *}{windowids}{list of posted windows}{OUT}
  3310. ** \param{Pint *}{totalsize}{length of posted windows list}{OUT}
  3311. ** \param{Pint *}{err}{error indicator}{OUT}
  3312. ** \paramend
  3313. ** \blurb{This function may be used to obtain a list of all windows
  3314. ** posted to the workstation {\tt wsid}.
  3315. ** The error code is a standard PHIGS error code.}
  3316. */
  3317. {
  3318.   ptkswindow *ptrwindow;
  3319.   Pint numstructs, i;
  3320.   Pposted_struct_list structlist;
  3321.  
  3322.   *err = 0;
  3323.   *totalsize = 0;
  3324.   ptrwindow = firstwind;
  3325.   while (ptrwindow != NULL)
  3326.   {
  3327.     if (ptrwindow->posted && 
  3328.        (ptrwindow->wsid == wsid))
  3329.       (*totalsize)++;
  3330.     ptrwindow = ptrwindow->next;
  3331.   }
  3332.   if (size >= *totalsize)
  3333.   {
  3334.     pinq_posted_structs(wsid, 0, 0, err, &structlist, &numstructs);
  3335.     structlist.postings = (Pposted_struct *)calloc(numstructs, 
  3336.                                               sizeof(Pposted_struct));
  3337.     pinq_posted_structs(wsid, numstructs, 0, err, &structlist, &numstructs);
  3338.     windowids->num_ints = 0;
  3339.     for (i = 0; i < structlist.num_postings; i++)
  3340.     {
  3341.       if (iswindow(structlist.postings[i].id, &ptrwindow))
  3342.       {
  3343.         windowids->ints[windowids->num_ints] = ptrwindow->windowid;
  3344.         windowids->num_ints++;
  3345.       }
  3346.     }
  3347.   }
  3348. }  /* ptk_inqpostedwindows */
  3349.  
  3350. /*--------------------------------------------------------------------------*/
  3351.  
  3352. /*function:external*/
  3353. extern void ptk_inqwindowids(C(Pint) size, C(Pint_list *) windowids, 
  3354.                            C(Pint *) totalsize, C(Pint *) err)
  3355. PreANSI(Pint size)
  3356. PreANSI(Pint_list *windowids)
  3357. PreANSI(Pint *totalsize)
  3358. PreANSI(Pint *err)
  3359. /*
  3360. ** \parambegin
  3361. ** \param{Pint}{size}{size of buffer}{IN}
  3362. ** \param{Pint\_list *}{windowids}{list of windows}{OUT}
  3363. ** \param{Pint *}{totalsize}{length of windows list}{OUT}
  3364. ** \param{Pint *}{err}{error indicator}{OUT}
  3365. ** \paramend
  3366. ** \blurb{This function may be used to obtain a list of all
  3367. ** windows in the PHIGS Toolkit window store.}
  3368. */
  3369. {
  3370.   ptkswindow *ptrwindow;
  3371.  
  3372.   *err = 0;
  3373.   *totalsize = windowcount;
  3374.   if (size >= *totalsize)
  3375.   {
  3376.     windowids->num_ints = 0;
  3377.     ptrwindow = firstwind;
  3378.     while (ptrwindow != NULL)
  3379.     {
  3380.       windowids->ints[windowids->num_ints] = ptrwindow->windowid;
  3381.       windowids->num_ints++;
  3382.       ptrwindow = ptrwindow->next;
  3383.     }
  3384.   }
  3385. }  /* ptk_inqwindowids */
  3386.  
  3387. /*--------------------------------------------------------------------------*/
  3388.  
  3389. /*function:external*/
  3390. extern void ptk_inqwindowstructid(C(Pint) windid, C(Pint *) windowstid, 
  3391.                                   C(Pint *) iconstid, C(Pint *) err)
  3392. PreANSI(Pint windid)
  3393. PreANSI(Pint *windowstid)
  3394. PreANSI(Pint *iconstid)
  3395. PreANSI(Pint *err)
  3396. /*
  3397. ** \parambegin
  3398. ** \param{Pint}{windid}{window identifier}{IN}
  3399. ** \param{Pint *}{windowstid}{window structure identifier}{OUT}
  3400. ** \param{Pint *}{iconstid}{window structure identifier}{OUT}
  3401. ** \param{Pint *}{err}{error indicator}{OUT}
  3402. ** \paramend
  3403. ** \blurb{This function may be used to obtain the identifier of
  3404. ** a window structure and its corresponding icon structure.
  3405. ** The window structure is a network with references to all the items
  3406. ** posted to the window. The default icon is a single structure
  3407. ** containing the window identifier.
  3408. ** The error code = 1 if {\tt windid} doesn't exist.}
  3409. */
  3410. {
  3411.   *err = 0;
  3412.   setwindow(windid);
  3413.   if (windptr != NULL)
  3414.   {
  3415.     *windowstid = windptr->windowstid;
  3416.     *iconstid = windptr->iconstid;
  3417.   }
  3418.   else
  3419.     *err = 1;
  3420. }  /* ptk_inqwindowstructid */
  3421.  
  3422. /*--------------------------------------------------------------------------*/
  3423.  
  3424. /*function:external*/
  3425. extern void ptk_inqwindowname(C(Pint) windid, C(Pint *) name, 
  3426.                             C(Pint *) err) 
  3427. PreANSI(Pint windid)
  3428. PreANSI(Pint *name)
  3429. PreANSI(Pint *err)
  3430. /*
  3431. ** \parambegin
  3432. ** \param{Pint}{windid}{window identifier}{IN}
  3433. ** \param{Pint *}{name}{window name}{OUT}
  3434. ** \param{Pint *}{err}{error indicator}{OUT}
  3435. ** \paramend
  3436. ** \blurb{This function may be used to obtain the window name 
  3437. ** to be used in namesets for the pick, invisibility and 
  3438. ** highlighting filters.
  3439. ** The error code = 1 if {\tt windid} doesn't exist.}
  3440. */
  3441. {
  3442.   *err = 0;
  3443.   setwindow(windid);
  3444.   if (windptr != NULL)
  3445.     *name = windptr->windowname;
  3446.   else
  3447.     *err = 1;
  3448. }  /* ptk_inqwindowname */
  3449.  
  3450. /*--------------------------------------------------------------------------*/
  3451.  
  3452. /*function:external*/
  3453. extern void ptk_inqwindowstate(C(Pint) windid, C(ptkewindowstate *) state, 
  3454.                             C(Pint *) err) 
  3455. PreANSI(Pint windid)
  3456. PreANSI(ptkewindowstate *state)
  3457. PreANSI(Pint *err)
  3458. /*
  3459. ** \parambegin
  3460. ** \param{Pint}{windid}{window identifier}{IN}
  3461. ** \param{ptkewindowstate *}{state}{window state, open or closed}{OUT}
  3462. ** \param{Pint *}{err}{error indicator}{OUT}
  3463. ** \paramend
  3464. ** \blurb{This function may be used to obtain the window state,
  3465. ** open or closed.
  3466. ** The error code = 1 if {\tt windid} doesn't exist.}
  3467. */
  3468. {
  3469.   *err = 0;
  3470.   setwindow(windid);
  3471.   if (windptr != NULL)
  3472.     *state = windptr->windowstate;
  3473.   else
  3474.     *err = 1;
  3475. }  /* ptk_inqwindowstate */
  3476.  
  3477. /*--------------------------------------------------------------------------*/
  3478.  
  3479. /*function:external*/
  3480. extern ptkboolean ptk_inqfrontbackwindowid(C(Pint) wsid, C(Pint *) frontid,
  3481.                 C(ptkewindowstate *) frontstate, C(Pint *) backid, 
  3482.                 C(ptkewindowstate *) backstate, C(Pint *) err)
  3483. PreANSI(Pint wsid)
  3484. PreANSI(Pint *frontid)
  3485. PreANSI(ptkewindowstate *frontstate)
  3486. PreANSI(Pint *backid)
  3487. PreANSI(ptkewindowstate *backstate)
  3488. PreANSI(Pint *err)
  3489. /*
  3490. ** \parambegin
  3491. ** \param{Pint}{wsid}{workstation identifier}{IN}
  3492. ** \param{Pint *}{frontstid}{front window identifier}{OUT}
  3493. ** \param{ptkewindowstate *}{frontstate}{front window state}{OUT}
  3494. ** \param{Pint *}{backstid}{back window identifier}{OUT}
  3495. ** \param{ptkewindowstate *}{backstate}{back window state}{OUT}
  3496. ** \param{Pint *}{err}{error indicator}{OUT}
  3497. ** \paramend
  3498. ** \blurb{This function may be used to obtain the identifiers
  3499. ** of the front and back windows and there current state (OPEN or
  3500. ** CLOSED).}
  3501. */
  3502. {
  3503.   Pint ind;
  3504.  
  3505.   *err = 0;
  3506.   findwsid(wsid, &ind);
  3507.   if (wswindows[ind].postedwindows)
  3508.   {
  3509.     *frontid = wswindows[ind].frontptr->windowid;
  3510.     *frontstate = wswindows[ind].frontptr->windowstate;
  3511.     *backid = wswindows[ind].backptr->windowid;
  3512.     *backstate = wswindows[ind].backptr->windowstate;
  3513.     return TRUE;
  3514.   }
  3515.   else 
  3516.     return FALSE;
  3517. }  /* ptk_inqfrontbackwindowid */
  3518.  
  3519. /*--------------------------------------------------------------------------*/
  3520.  
  3521. /*function:external*/
  3522. extern void ptk_inqwindowposition(C(Pint) windid, C(Ppoint *) position,
  3523.                                   C(Pint *) err) 
  3524. PreANSI(Pint windid)
  3525. PreANSI(Ppoint *position)
  3526. PreANSI(Pint *err)
  3527. /*
  3528. ** \parambegin
  3529. ** \param{Pint}{windid}{window identifier}{IN}
  3530. ** \param{Ppoint *}{position}{window position}{OUT}
  3531. ** \param{Pint *}{err}{error indicator}{OUT}
  3532. ** \paramend
  3533. ** \blurb{This function may be used to obtain the position of the centre
  3534. ** of a window. The position is returned in the range [0, 1].
  3535. ** The error code = 1 if {\tt windid} doesn't exist.}
  3536. */
  3537. {
  3538.   *err = 0;
  3539.   setwindow(windid);
  3540.   if (windptr != NULL)
  3541.     *position = windptr->windowposition;
  3542.   else
  3543.     *err = 1;
  3544. }  /* ptk_inqwindowposition */
  3545.  
  3546. /*--------------------------------------------------------------------------*/
  3547.  
  3548. /*function:external*/
  3549. extern void ptk_inqwindowsize(C(Pint) windid, C(Ppoint *) size, 
  3550.                               C(Pint *) err) 
  3551. PreANSI(Pint windid)
  3552. PreANSI(Ppoint *size)
  3553. PreANSI(Pint *err)
  3554. /*
  3555. ** \parambegin
  3556. ** \param{Pint}{windid}{window identifier}{IN}
  3557. ** \param{Ppoint *}{size}{window size}{OUT}
  3558. ** \param{Pint *}{err}{error indicator}{OUT}
  3559. ** \paramend
  3560. ** \blurb{This function may be used to obtain the size of a window
  3561. ** which is returned in the range [0, 1].
  3562. ** The error code = 1 if {\tt windid} doesn't exist.}
  3563. */
  3564. {
  3565.   *err = 0;
  3566.   setwindow(windid);
  3567.   if (windptr != NULL)
  3568.     *size = windptr->windowsize;
  3569.   else
  3570.     *err = 1;
  3571. }  /* ptk_inqwindowsize */
  3572.  
  3573. /*--------------------------------------------------------------------------*/
  3574.  
  3575. /*function:external*/
  3576. extern void ptk_inqiconposition(C(Pint) windid, C(Ppoint *) position, 
  3577.                                 C(Pint *) err) 
  3578. PreANSI(Pint windid)
  3579. PreANSI(Ppoint *position)
  3580. PreANSI(Pint *err)
  3581. /*
  3582. ** \parambegin
  3583. ** \param{Pint}{windid}{window identifier}{IN}
  3584. ** \param{Ppoint *}{position}{icon position}{OUT}
  3585. ** \param{Pint *}{err}{error indicator}{OUT}
  3586. ** \paramend
  3587. ** \blurb{This function may be used to obtain the position of the centre of 
  3588. ** a window icon which is returned in the range [0, 1].
  3589. ** The error code = 1 if {\tt windid} doesn't exist.}
  3590. */
  3591. {
  3592.   *err = 0;
  3593.   setwindow(windid);
  3594.   if (windptr != NULL)
  3595.     *position = windptr->iconposition;
  3596.   else
  3597.     *err = 1;
  3598. }  /* ptk_inqiconposition */
  3599.  
  3600. /*--------------------------------------------------------------------------*/
  3601.  
  3602. /*function:external*/
  3603. extern void ptk_inqiconsize(C(Pint) windid, C(Ppoint *) size, C(Pint *) err) 
  3604. PreANSI(Pint windid)
  3605. PreANSI(Ppoint *size)
  3606. PreANSI(Pint *err)
  3607. /*
  3608. ** \parambegin
  3609. ** \param{Pint}{windid}{window identifier}{IN}
  3610. ** \param{Ppoint *}{size}{icon size}{OUT}
  3611. ** \param{Pint *}{err}{error indicator}{OUT}
  3612. ** \paramend
  3613. ** \blurb{This function may be used to obtain the size of a window's icon
  3614. ** structure and is returned in the range [0, 1].
  3615. ** The error code = 1 if {\tt windid} doesn't exist.}
  3616. */
  3617. {
  3618.   *err = 0;
  3619.   setwindow(windid);
  3620.   if (windptr != NULL)
  3621.     *size = windptr->iconsize;
  3622.   else
  3623.     *err = 1;
  3624. }  /* ptk_inqiconsize */
  3625.  
  3626. /*--------------------------------------------------------------------------*/
  3627.  
  3628. /*function:external*/
  3629. extern void ptk_inqusericon(C(Pint) windid, C(Pint *) iconstid,
  3630.                              C(Pint *) err) 
  3631. PreANSI(Pint windid)
  3632. PreANSI(Pint *iconstid)
  3633. PreANSI(Pint *err)
  3634. /*
  3635. ** \parambegin
  3636. ** \param{Pint}{windid}{window identifier}{IN}
  3637. ** \param{Pint *}{iconstid}{user icon structure identifier}{OUT}
  3638. ** \param{Pint *}{err}{error indicator}{OUT}
  3639. ** \paramend
  3640. ** \blurb{This function may be used to obtain the identifier of a
  3641. ** user created icon structure. The structure is referenced by the
  3642. ** window's icon structure.
  3643. ** The error code = 1 if {\tt windid} doesn't exist and = 2 if
  3644. ** the default icon is used.}
  3645. */
  3646. {
  3647.   *err = 0;
  3648.   setwindow(windid);
  3649.   if (windptr != NULL)
  3650.   {
  3651.     if (!windptr->defaulticon)
  3652.       *iconstid = windptr->usericon;
  3653.     else
  3654.       *err = 2;
  3655.   }
  3656.   else
  3657.     *err = 1;
  3658. }  /* ptk_inqusericon */
  3659.  
  3660. /*--------------------------------------------------------------------------*/
  3661.  
  3662. /*function:external*/
  3663. extern void ptk_inqframesize(C(Pint) windid, C(Ppoint *) size, 
  3664.                               C(Pint *) err) 
  3665. PreANSI(Pint windid)
  3666. PreANSI(Ppoint *size)
  3667. PreANSI(Pint *err)
  3668. /*
  3669. ** \parambegin
  3670. ** \param{Pint}{windid}{window identifier}{IN}
  3671. ** \param{Ppoint *}{size}{frame size}{OUT}
  3672. ** \param{Pint *}{err}{error indicator}{OUT}
  3673. ** \paramend
  3674. ** \blurb{This function may be used to obtain the dimensions of the
  3675. ** window frame. They are returned in the range [0, 1] and the default
  3676. ** dimensions are (0.01, 0.01).
  3677. ** The error code = 1 if {\tt windid} doesn't exist.}
  3678. */
  3679. {
  3680.   *err = 0;
  3681.   setwindow(windid);
  3682.   if (windptr != NULL)
  3683.     *size = windptr->framesize;
  3684.   else
  3685.     *err = 1;
  3686. }  /* ptk_inqframesize */
  3687.  
  3688. /*--------------------------------------------------------------------------*/
  3689.  
  3690. /*function:external*/
  3691. extern void ptk_inqwindowtype(C(Pint) windid, C(ptkewindowtype *) type, 
  3692.                               C(Pint *) err) 
  3693. PreANSI(Pint windid)
  3694. PreANSI(ptkewindowtype *type)
  3695. PreANSI(Pint *err)
  3696. /*
  3697. ** \parambegin
  3698. ** \param{Pint}{windid}{window identifier}{IN}
  3699. ** \param{ptkewindowtype *}{type}{window type}{OUT}
  3700. ** \param{Pint *}{err}{error indicator}{OUT}
  3701. ** \paramend
  3702. ** \blurb{This function may be used to inquire the type of a window.
  3703. ** The available types are STRUCT, TOPOLOGY, CONTENT and TERMINAL.
  3704. ** The default window type is STRUCT and may be used to view any PHIGS
  3705. ** structures.
  3706. ** The error code = 1 if {\tt windid} doesn't exist.}
  3707. */
  3708. {
  3709.   *err = 0;
  3710.   setwindow(windid);
  3711.   if (windptr != NULL)
  3712.     *type = windptr->windowtype;
  3713.   else
  3714.     *err = 1;
  3715. }  /* ptk_inqwindowtype */
  3716.  
  3717. /*--------------------------------------------------------------------------*/
  3718.  
  3719. /*function:external*/
  3720. extern void ptk_inqwindowattrs(C(Pint) windid,
  3721.       C(Pint *) titlefont, C(Pint *) titlecolour, C(Pint *) bannercolour,
  3722.       C(Pint *) backgdcolour, C(Pint *) edgecolour, 
  3723.       C(Pint *) frametlcolour, C(Pint *) framebrcolour, C(Pint *) err)
  3724. PreANSI(Pint windid)
  3725. PreANSI(Pint *titlefont)
  3726. PreANSI(Pint *titlecolour)
  3727. PreANSI(Pint *bannercolour)
  3728. PreANSI(Pint *backgdcolour)
  3729. PreANSI(Pint *edgecolour)
  3730. PreANSI(Pint *frametlcolour)
  3731. PreANSI(Pint *framebrcolour)
  3732. PreANSI(Pint *err)
  3733. /* 
  3734. ** \parambegin
  3735. ** \param{Pint}{windid}{window identifier}{IN}
  3736. ** \param{Pint *}{titlefont}{title string font}{OUT}
  3737. ** \param{Pint *}{titlecolour}{title string colour index}{OUT}
  3738. ** \param{Pint *}{bannercolour}{banner colour index}{OUT}
  3739. ** \param{Pint *}{backgdcolour}{background colour index of window}{OUT}
  3740. ** \param{Pint *}{edgecolour}{edge colour index of window}{OUT}
  3741. ** \param{Pint *}{frametlcolour}{top-left frame colour index}{OUT}
  3742. ** \param{Pint *}{framebrcolour}{bottom-right frame colour index}{OUT}
  3743. ** \param{Pint *}{err}{error indicator}{OUT}
  3744. ** \paramend
  3745. ** \blurb{This function may be used to obtain the text font and
  3746. ** colour attribute values of a window.
  3747. ** The error code = 1 if {\tt windid} doesn't exist.}
  3748. */
  3749. {   
  3750.   *err = 0;
  3751.   setwindow(windid);
  3752.   if (windptr != NULL)
  3753.   {  
  3754.     *titlefont = windptr->titlefont;
  3755.     *titlecolour = windptr->titlecolour;  
  3756.     *bannercolour = windptr->bannercolour;
  3757.     *backgdcolour = windptr->backgdcolour;
  3758.     *edgecolour = windptr->edgecolour;
  3759.     *frametlcolour = windptr->frametlcolour;
  3760.     *framebrcolour = windptr->framebrcolour;
  3761.   }
  3762.   else
  3763.     *err = 1;
  3764. }  /* ptk_inqwindowattrs */
  3765.  
  3766. /*--------------------------------------------------------------------------*/
  3767. /*-------------------------- icon functions --------------------------------*/
  3768. /*--------------------------------------------------------------------------*/
  3769.  
  3770. /*function:external*/
  3771. extern void ptk_seticonposition(C(Pint) windid, C(Ppoint *) position)
  3772. PreANSI(Pint windid)
  3773. PreANSI(Ppoint *position)
  3774. /*
  3775. ** \parambegin
  3776. ** \param{Pint}{windid}{window identifier}{IN}
  3777. ** \param{Ppoint *}{position}{icon position}{IN}
  3778. ** \paramend 
  3779. ** \blurb{This function sets the position of the centre of the 
  3780. ** window's icon structure. The position is given in the range [0, 1].}
  3781. */
  3782. { 
  3783.   setwindow(windid);
  3784.   if (windptr != NULL)
  3785.   {
  3786.     if ((position->x > 0.0) && (position->x < 1.0) &&
  3787.         (position->y > 0.0) && (position->y < 1.0))
  3788.     {
  3789.       windptr->iconposition = *position;
  3790.       updateicon();
  3791.     }
  3792.   }
  3793. }  /* ptk_seticonposition */
  3794.  
  3795. /*--------------------------------------------------------------------------*/
  3796.  
  3797. /*function:external*/
  3798. extern void ptk_seticonsize(C(Pint) windid, C(Ppoint *) size)
  3799. PreANSI(Pint windid)
  3800. PreANSI(Ppoint *size)
  3801. /*
  3802. ** \parambegin
  3803. ** \param{Pint}{windid}{window identifier}{IN}
  3804. ** \param{Ppoint *}{size}{icon size}{IN}
  3805. ** \paramend 
  3806. ** \blurb{This function sets the size of the window's icon structure.
  3807. ** The size is given in the range [0, 1].}
  3808. */
  3809. {
  3810.   setwindow(windid);
  3811.   if (windptr != NULL)
  3812.   {
  3813.     if ((size->x > 0.0) && (size->y > 0.0))
  3814.     {  
  3815.       windptr->iconsize = *size;
  3816.       updateicon();
  3817.     }
  3818.   }
  3819. }  /* ptk_seticonsize */
  3820.  
  3821. /*--------------------------------------------------------------------------*/
  3822.  
  3823. /*function:external*/
  3824. extern void ptk_setusericon(C(Pint) windid, C(Pint) usericon)
  3825. PreANSI(Pint windid)
  3826. PreANSI(Pint usericon)
  3827. /*
  3828. ** \parambegin
  3829. ** \param{Pint}{windid}{window identifier}{IN}
  3830. ** \param{Pint}{user icon}{icon structure identifier}{IN}
  3831. ** \paramend 
  3832. ** \blurb{This function enables the application to specify a structure
  3833. ** identifier to use as a window icon. The structure is executed from
  3834. ** the window's default icon structure and the icon size and position
  3835. ** functions still apply provided the user icon is defined within
  3836. ** the World Coordinate range [0, 1].}
  3837. */
  3838. {
  3839.   setwindow(windid);
  3840.   if (windptr != NULL)
  3841.   {
  3842.     if (windptr->defaulticon)
  3843.     {
  3844.       ptk_openstruct(windptr->iconstid);
  3845.       pset_elem_ptr(0);
  3846.       pdel_elems_labels(ptk_stringtoint("label", "begin-icon"), 
  3847.                       ptk_stringtoint("label", "end-icon"));  
  3848.       ptk_seteditmode(PEDIT_INSERT);
  3849.       pexec_struct(usericon);
  3850.       ptk_unseteditmode();
  3851.       ptk_closestruct(); 
  3852.       windptr->defaulticon = FALSE;
  3853.     }
  3854.   }
  3855. }  /* ptk_setusericon */
  3856.  
  3857. /*--------------------------------------------------------------------------*/
  3858. /*------------------------- banner functions -------------------------------*/
  3859.  
  3860. /*function:external*/
  3861. extern void ptk_setbannercolours(C(Pint) windid, C(Pint) bannercolour, 
  3862.                                C(Pint) titlecolour)
  3863. PreANSI(Pint windid)
  3864. PreANSI(Pint bannercolour)
  3865. PreANSI(Pint titlecolour)
  3866. /*
  3867. ** \parambegin
  3868. ** \param{Pint}{windid}{window identifier}{IN}
  3869. ** \param{Pint}{bannercolour}{banner colour index}{IN}
  3870. ** \param{Pint}{titlecolour}{title string colour index}{IN}
  3871. ** \paramend 
  3872. ** \blurb{This function sets the colour indicies of a window banner.
  3873. ** It is useful for highlighting a current window, for example
  3874. ** in a `point and click' window system.}
  3875. */
  3876. {
  3877.   setwindow(windid);
  3878.   if (windptr != NULL)
  3879.   {
  3880.     windptr->bannercolour = bannercolour;
  3881.     windptr->titlecolour = titlecolour;
  3882.     updateframe();
  3883.   }
  3884. }  /* ptk_setbannercolours */
  3885.  
  3886. /*--------------------------------------------------------------------------*/
  3887.  
  3888. /*function:external*/
  3889. extern void ptk_setbannerheight(C(Pint) windid, C(Pfloat) bannerheight)
  3890. PreANSI(Pint windid)
  3891. PreANSI(Pfloat bannerheight)
  3892. /*
  3893. ** \parambegin
  3894. ** \param{Pint}{windid}{window identifier}{IN}
  3895. ** \param{Pfloat}{bannerheight}{height of banner}{IN}
  3896. ** \paramend 
  3897. ** \blurb{This function sets the height of the window banner to
  3898. ** {\tt bannerheight} which is given in the range [0, 1]. The window
  3899. ** title is re-scaled to fit the new height.}
  3900. */
  3901. {
  3902.   setwindow(windid);
  3903.   if (windptr != NULL)
  3904.   {
  3905.     windptr->bannerheight = bannerheight;
  3906.     updateframe();
  3907.   }
  3908. }  /* ptk_setbannerheight */
  3909.  
  3910. /*--------------------------------------------------------------------------*/
  3911.  
  3912. /*function:external*/
  3913. extern void ptk_inqbannerheight(C(Pint) windid, C(Pfloat *) bannerheight,
  3914.                                 C(Pint *) err)
  3915. PreANSI(Pint windid)
  3916. PreANSI(Pfloat *bannerheight)
  3917. PreANSI(Pint *err)
  3918. /*
  3919. ** \parambegin
  3920. ** \param{Pint}{windid}{window identifier}{IN}
  3921. ** \param{Pfloat *}{bannerheight}{height of banner}{OUT}
  3922. ** \param{Pint *}{err}{error indicator}{OUT}
  3923. ** \paramend 
  3924. ** \blurb{This function may be used to obtain the height of a window
  3925. ** banner. It is returned in the range [0, 1].
  3926. ** The error code = 1 if {\tt windid} doesn't exist.}
  3927. */
  3928. {
  3929.   *err = 0;
  3930.   setwindow(windid);
  3931.   if (windptr != NULL)
  3932.     *bannerheight = windptr->bannerheight;
  3933.   else
  3934.     *err = 1;
  3935. }  /* ptk_inqbannerheight */
  3936.  
  3937. /*--------------------------------------------------------------------------*/
  3938.  
  3939. /*function:external*/
  3940. extern void ptk_setbannertitle(C(Pint) windid, C(char *) titlestring)
  3941. PreANSI(Pint windid)
  3942. PreANSI(char *titlestring)
  3943. /*
  3944. ** \parambegin
  3945. ** \param{Pint}{windid}{window identifier}{IN}
  3946. ** \param{char *}{titlestring}{title string of window banner}{IN}
  3947. ** \paramend 
  3948. ** \blurb{This function sets the title string of a window. The title
  3949. ** is displayed in the window banner and is automatically scaled to
  3950. ** fit inside the banner area.}
  3951. */
  3952. {
  3953.   setwindow(windid);
  3954.   if (windptr != NULL)
  3955.   {  
  3956.     strncpy(windptr->titlestring, titlestring, strlen(titlestring) + 1);
  3957.     updateframe();
  3958.   }
  3959. }  /* ptk_setbannertitle */
  3960.  
  3961. /*--------------------------------------------------------------------------*/
  3962.  
  3963. /*function:external*/
  3964. extern void ptk_inqbannertitle(C(Pint) windid, C(Pint) len,
  3965.                     C(char *) titlestr, C(Pint *) totlen, C(Pint *) err)
  3966. PreANSI(Pint windid)
  3967. PreANSI(Pint len)
  3968. PreANSI(char *titlestr)
  3969. PreANSI(Pint *totlen)
  3970. PreANSI(Pint *err)
  3971. /*
  3972. ** \parambegin
  3973. ** \param{Pint}{windid}{window identifier}{IN}
  3974. ** \param{Pint}{len}{length of string}{IN}
  3975. ** \param{char *}{titlestr}{title string of banner}{IN}
  3976. ** \param{Pint *}{totlen}{actual length of string}{OUT}
  3977. ** \param{Pint *}{err}{error indicator}{OUT}
  3978. ** \paramend 
  3979. ** \blurb{This function may be used to obtain the title of a window.
  3980. ** The error code = 1 if {\tt windid} doesn't exist.}
  3981. */
  3982. {
  3983.   *err = 0;
  3984.   setwindow(windid);
  3985.   if (windptr != NULL)
  3986.   {  
  3987.     *totlen = strlen(windptr->titlestring) + 1;
  3988.     if (len >= *totlen)
  3989.       strncpy(titlestr, windptr->titlestring, *totlen);
  3990.   }
  3991.   else
  3992.     *err = 1;
  3993. }  /* ptk_inqbannertitle */
  3994.  
  3995. /*--------------------------------------------------------------------------*/
  3996. /*---------------------- Terminal window functions -------------------------*/
  3997. /*--------------------------------------------------------------------------*/
  3998.  
  3999. static void addline(C(char *) line, C(Pedit_mode) edtype)
  4000. PreANSI(char *line)
  4001. PreANSI(Pedit_mode edtype)
  4002. /*
  4003. ** \parambegin
  4004. ** \param{}{termnum}{index to terminal window array}{IN}
  4005. ** \param{}{line}{line to add or replace}{IN}
  4006. ** \param{}{edtype}{edit mode}{IN}
  4007. ** \paramend
  4008. ** \blurb{Updates the PHIGS structure containing the terminal window
  4009. ** text. Either replaces the last line or inserts a new one.}
  4010. */
  4011. {
  4012.   Ppoint textpos;
  4013.   Pint i;
  4014.  
  4015.   /* initialise ptr to last elem */
  4016.   /* remove old text elements from structure */
  4017.   ptk_openstruct(windptr->term.textstid);
  4018.   poffset_elem_ptr(-1);
  4019.   ptk_seteditmode(edtype);
  4020.  
  4021.   /* insert new text element */
  4022.   i = windptr->term.curr_line;
  4023.   textpos = ptk_point(ptkctmlinespace,
  4024.                       -(Pfloat)i * windptr->term.increment);
  4025.   ptext(&textpos, line);
  4026.   ptk_unseteditmode();
  4027.   ptk_closestruct();
  4028. }  /* addline */
  4029.  
  4030. /*--------------------------------------------------------------------------*/
  4031.  
  4032. static void setterminalline()
  4033. {
  4034.   Pfloat oneline;
  4035.  
  4036.   /* view orientation */
  4037.   oneline = -windptr->windowsize.y/(Pfloat)windptr->term.lines;
  4038.   windptr->vrp = ptk_point3(0.0, -windptr->windowsize.y + 
  4039.                    (oneline * (Pfloat)(windptr->term.visline - 1)), 0.0);
  4040.   /* set view rep */
  4041.   updateview();
  4042. }  /* setterminalline */
  4043.  
  4044. /*--------------------------------------------------------------------------*/
  4045.  
  4046. /*function:external*/
  4047. extern void ptk_scrollterminal(C(Pint) windid, C(Ptext_path) scrolldir,
  4048.                            C(Pint) numlines)
  4049. PreANSI(Pint windid)
  4050. PreANSI(Ptext_path scrolldir)
  4051. PreANSI(Pint numlines)
  4052. /*
  4053. ** \parambegin
  4054. ** \param{}{windid}{terminal window identifier}{IN}
  4055. ** \param{}{scrolldir}{scroll direction (up or down)}{IN}
  4056. ** \param{}{numlines}{number of lines to scroll by}{IN}
  4057. ** \paramend
  4058. ** \blurb{This function scrolls the contents of the TERMINAL window
  4059. ** either UP or DOWN by {\tt numlines}.}
  4060. */
  4061. {
  4062.   setwindow(windid);
  4063.   if (windptr != NULL)
  4064.   {
  4065.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4066.     {
  4067.       switch (scrolldir)
  4068.       {
  4069.       case PPATH_DOWN: 
  4070.         windptr->term.visline -= numlines;  
  4071.         break;
  4072.     
  4073.       case PPATH_UP:
  4074.         windptr->term.visline += numlines;
  4075.         break;
  4076.     
  4077.       case PPATH_LEFT:
  4078.         break;
  4079.     
  4080.       case PPATH_RIGHT:
  4081.         break;
  4082.       }
  4083.       setterminalline();
  4084.     }
  4085.   }
  4086. }  /* ptk_scrollterminal */
  4087.  
  4088. /*--------------------------------------------------------------------------*/
  4089.  
  4090. /*function:external*/
  4091. extern void ptk_setterminaldata(C(Pint) windid, C(Pint) numlines,
  4092.                                 C(Pint) txfont, C(Pint) txcolour)
  4093. PreANSI(Pint windid)
  4094. PreANSI(Pint numlines)
  4095. PreANSI(Pint txfont)
  4096. PreANSI(Pint txcolour)
  4097. /*
  4098. ** \parambegin
  4099. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4100. ** \param{Pint}{numlines}{number of lines in window}{IN}
  4101. ** \param{Pint}{numcolmns}{number of columns in window}{IN}
  4102. ** \param{Pint}{txfont}{text font}{IN}
  4103. ** \param{Pint}{txcolour}{text colour}{IN}
  4104. ** \paramend
  4105. ** \blurb{This function sets the number of lines to be displayed in a 
  4106. ** TERMINAL window and which text font and colour to use.}
  4107. */
  4108. {
  4109.   char stname[30];
  4110.   Pint termnum, err, wstype;
  4111.   Pfloat linespace, chrht, textheight, textwidth;
  4112.   Ptext_align align;
  4113.   void *connid;
  4114.   Prect rect;
  4115.   Ppoint offset;
  4116.   Pfloat wwidth, wheight, charheight, charwidth, lineheight;
  4117.   Pstore store;
  4118.  
  4119.   setwindow(windid);
  4120.   if (windptr != NULL)
  4121.   {
  4122.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4123.     {
  4124.       windptr->term.lines = numlines;
  4125.     
  4126.       /* create structure with appropriate attr */
  4127.       pempty_struct(windptr->term.textstid);
  4128.       ptk_openstruct(windptr->term.textstid);
  4129.     
  4130.       /* user specified font*/
  4131.       windptr->term.txfont = txfont;
  4132.       windptr->term.txcolour = txcolour;
  4133.       pset_text_font(txfont);
  4134.       pset_text_colr_ind(txcolour);
  4135.       align.hor = PHOR_NORM;
  4136.       align.vert = PVERT_BOTTOM;
  4137.       pset_text_align(&align);
  4138.       /* size characters so they all fit within window */
  4139.       textwidth = windptr->windowsize.x * 0.99;
  4140.       textheight = windptr->windowsize.y * 0.9;
  4141.       linespace = (windptr->windowsize.y * 0.1)/(Pfloat)windptr->term.lines;
  4142.  
  4143.       /* character height */
  4144.       /* Implementation dependent bit because HP and PEXSI doesn't support
  4145.       ** INQUIRE TEXT EXTENT. For HP and PEXSI assume font 1.
  4146.       */
  4147. #ifdef SUN
  4148.       pcreate_store(&err, &store);
  4149.       pinq_ws_conn_type(windptr->wsid, store, &err, &connid, &wstype);
  4150.       pinq_text_extent(wstype, txfont, 1.0, 0.0, 0.01, PPATH_RIGHT, 
  4151.         PHOR_NORM, PVERT_NORM, "W", &err, &rect, &offset);
  4152. #endif
  4153. #ifdef HP
  4154.       rect.p = ptk_point(0.0, 0.0);
  4155.       rect.q = ptk_point(0.01, 0.015);
  4156. #endif
  4157. #ifdef PEXSI
  4158.       rect.p = ptk_point(0.0, 0.0);
  4159.       rect.q = ptk_point(0.01, 0.015);
  4160. #endif
  4161.  
  4162.       wheight = rect.q.y - rect.p.y;
  4163.       wwidth = rect.q.x - rect.p.x;
  4164.       
  4165.       lineheight = textheight / (Pfloat)numlines;
  4166.       charheight = 0.01 * (lineheight / wheight);
  4167.       charwidth = wwidth * (lineheight / wheight);
  4168.       pset_char_ht(charheight);
  4169.       windptr->term.increment = textheight/(Pfloat)windptr->term.lines 
  4170.                                  + linespace;
  4171.       windptr->term.realcols = textwidth / charwidth;
  4172.       windptr->term.columns = (Pint)windptr->term.realcols;
  4173.       windptr->term.reallines = (Pfloat)numlines;
  4174.       plabel(ptk_stringtoint("label", "$tm_starttext"));
  4175.       /* put text elements here */
  4176.       plabel(ptk_stringtoint("label", "$tm_endtext"));
  4177.       ptk_closestruct();
  4178.       ptk_delstore(store);
  4179.     }
  4180.   }
  4181. }  /* ptk_setterminaldata */
  4182.  
  4183. /*--------------------------------------------------------------------------*/
  4184.  
  4185. /*function:external*/
  4186. extern void ptk_inqterminaldata(C(Pint) windid, C(Pint *) numlines,
  4187.             C(Pint *) numcolms, C(Pint *) txfont, C(Pint *) txcolour,
  4188.             C(Pint *) err)
  4189. PreANSI(Pint windid)
  4190. PreANSI(Pint *numlines)
  4191. PreANSI(Pint *numcolms)
  4192. PreANSI(Pint *txfont)
  4193. PreANSI(Pint *txcolour)
  4194. PreANSI(Pint *err)
  4195. /*
  4196. ** \parambegin
  4197. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4198. ** \param{Pint *}{numlines}{number of lines in window}{OUT}
  4199. ** \param{Pint *}{numcolmns}{number of columns in window}{OUT}
  4200. ** \param{Pint *}{txfont}{text font}{OUT}
  4201. ** \param{Pint *}{txcolour}{text colour}{OUT}
  4202. ** \param{Pint *}{err}{error indicator}{OUT}
  4203. ** \paramend
  4204. ** \blurb{This function may be used to obtain the number of lines
  4205. ** displayed in a TERMINAL window and the number of characters in a line.
  4206. ** Also the text font and colour used are returned in {\tt txfont} and
  4207. ** {\tt txcolour}. The error code = 1 if {\tt windid} doesn't exist
  4208. ** and = 2 if it is not a terminal window.}
  4209. */
  4210. {
  4211.   *err = 0;
  4212.   setwindow(windid);
  4213.   if (windptr != NULL)
  4214.   {
  4215.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4216.     {
  4217.       *numlines = windptr->term.lines;    
  4218.       *numcolms = windptr->term.columns;    
  4219.       *txfont = windptr->term.txfont;
  4220.       *txcolour = windptr->term.txcolour;
  4221.     }
  4222.     else
  4223.       *err = 2;
  4224.   }
  4225.   else
  4226.     *err = 1;
  4227. }  /* ptk_inqterminaldata */
  4228.  
  4229. /*--------------------------------------------------------------------------*/
  4230.  
  4231. /*function:external*/
  4232. extern void ptk_refreshterminal(C(Pint) windid)
  4233. PreANSI(Pint windid)
  4234. /*
  4235. ** \parambegin
  4236. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4237. ** \paramend
  4238. ** \blurb{This function refreshes the TERMINAL window so that the
  4239. ** last text line is visible.}
  4240. */
  4241. {
  4242.   Pint linediff;
  4243.  
  4244.   /* show updates */
  4245.   setwindow(windid);
  4246.   if (windptr != NULL)
  4247.   {
  4248.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4249.     {
  4250.       linediff = windptr->term.curr_line - windptr->term.visline;
  4251.       if (abs(linediff) >= windptr->term.lines)
  4252.       {
  4253.         windptr->term.visline = windptr->term.curr_line - 
  4254.                                 windptr->term.lines + 1; 
  4255.         setterminalline();
  4256.       }
  4257.     }
  4258.   }
  4259. }  /* ptk_refreshterminal */
  4260.  
  4261. /*--------------------------------------------------------------------------*/
  4262.  
  4263. /*function:external*/
  4264. extern void ptk_writeterminal(C(Pint) windid, C(char *) str)
  4265. PreANSI(Pint windid)
  4266. PreANSI(char *str)
  4267. /*
  4268. ** \parambegin
  4269. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4270. ** \param{char *}{str}{string to write to window}{IN}
  4271. ** \paramend
  4272. ** \blurb{This function writes a character string to the current line
  4273. ** of the TERMINAL window. A new line is started when the end of the
  4274. ** current line is reached.}
  4275. */
  4276. { 
  4277.   Pint wtlen, spaceleft, stringleft, allocsize;
  4278.   Pint cpylen;
  4279.   char *templine;
  4280.   Pint termnum;
  4281.   Pedit_mode emode;
  4282.  
  4283.   setwindow(windid);
  4284.   if (windptr != NULL)
  4285.   {
  4286.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4287.     {
  4288.       templine = windptr->term.lastline;
  4289.     
  4290.       /* length of string to write */
  4291.       wtlen = strlen(str);
  4292.     
  4293.       /* number of character spaces left on current line */
  4294.       spaceleft = windptr->term.columns - windptr->term.curr_colm;
  4295.     
  4296.       /* add into current line if possible */
  4297.     
  4298.       if (spaceleft > 0)
  4299.       {
  4300.         /* allocate space for line */
  4301.         if (wtlen > spaceleft)
  4302.           /* spans more than one line */
  4303.           allocsize = windptr->term.columns + 1;
  4304.         else
  4305.           /* fits entirely on current line */
  4306.           allocsize = windptr->term.curr_colm + wtlen + 1;
  4307.         if (templine == NULL)
  4308.         {
  4309.           templine = (char *)malloc(allocsize);
  4310.           emode = PEDIT_INSERT;
  4311.         }
  4312.         else
  4313.         {
  4314.           templine = (char *)realloc(windptr->term.lastline, allocsize);
  4315.           emode = PEDIT_REPLACE;
  4316.         }
  4317.     
  4318.         /* cpylen = min(wtlen, spaceleft) */
  4319.         cpylen = wtlen < spaceleft ? wtlen : spaceleft;
  4320.     
  4321.         /* copy as much of str as possible into current line */
  4322.         strncpy(&templine[windptr->term.curr_colm], 
  4323.                 str, cpylen);
  4324.     
  4325.         windptr->term.curr_colm = allocsize - 1;
  4326.         templine[allocsize - 1] = '\0';   
  4327.         addline(templine, emode);
  4328.       }
  4329.     
  4330.       stringleft = wtlen - spaceleft;
  4331.     
  4332.       while (stringleft > 0)
  4333.       {
  4334.         /* create a new line */
  4335.         /* allocate space for line */
  4336.     
  4337.         if (stringleft > windptr->term.columns)
  4338.           allocsize = windptr->term.columns + 1;
  4339.         else
  4340.           allocsize = stringleft + 1;
  4341.         free(templine);
  4342.         templine = NULL;
  4343.         templine = (char *)malloc(sizeof(char) * allocsize);
  4344.           
  4345.         /* copy as much of string as possible */
  4346.         strncpy(templine, &str[wtlen - stringleft], 
  4347.                 allocsize); 
  4348.         windptr->term.curr_line++;
  4349.         windptr->term.curr_colm = allocsize - 1;
  4350.         templine[allocsize - 1] = '\0';
  4351.         stringleft -= windptr->term.columns;
  4352.         addline(templine, PEDIT_INSERT);
  4353.    
  4354.       }  /* while */
  4355.  
  4356.       windptr->term.lastline = templine;
  4357.  
  4358.       ptk_refreshterminal(windid);
  4359.     }
  4360.   }
  4361. }  /* ptk_writeterminal */
  4362.  
  4363. /*--------------------------------------------------------------------------*/
  4364.  
  4365. /*function:external*/
  4366. extern void ptk_writelnterminal(C(Pint) windid, C(char *) str)
  4367. PreANSI(Pint windid)
  4368. PreANSI(char *str)
  4369. /*
  4370. ** \parambegin
  4371. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4372. ** \param{char *}{str}{string to write to window}{IN}
  4373. ** \paramend
  4374. ** \blurb{This function writes a character string to the current line
  4375. ** of the TERMINAL window. A new line is started when the end of the current
  4376. ** line is reached and at the next call to a TERMINAL write function.}
  4377. */
  4378. {
  4379.   setwindow(windid);
  4380.   if (windptr != NULL)
  4381.   {
  4382.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4383.     {    
  4384.       ptk_writeterminal(windid, str);
  4385.       /* goto end of line */
  4386.       windptr->term.curr_colm = windptr->term.columns;
  4387.     }
  4388.   }
  4389. }  /* ptk_writelnterminal */
  4390.  
  4391. /*--------------------------------------------------------------------------*/
  4392.  
  4393. /*function:external*/
  4394. extern void ptk_printfterminal(C(Pint) windid, C(char *) format, va_alist)
  4395. PreANSI(Pint windid)
  4396. PreANSI(char *format)
  4397. va_dcl
  4398. /*
  4399. ** \parambegin
  4400. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4401. ** \param{char *}{format}{format string}{IN}
  4402. ** \param{}{va\_alist}{variable length argument list}{IN}
  4403. ** \paramend
  4404. ** \blurb{This function writes to a TERMINAL window using a variable length
  4405. ** argument list and a format string like the C printf function.}
  4406. */
  4407. {
  4408.   va_list args;
  4409.   char str[255], line[255];
  4410.   char *newline, *firstchar;
  4411.  
  4412.   va_start(args);
  4413.   vsprintf(str, format, args);
  4414.   va_end(args);
  4415.  
  4416.   firstchar = &str[0];
  4417.   while ((newline = strchr(firstchar, '\n')) != NULL)
  4418.   {
  4419.     strncpy(line, firstchar, (newline - firstchar)); 
  4420.     line[newline - firstchar] = '\0';
  4421.     ptk_writelnterminal(windid, line);
  4422.     firstchar = newline + 1;
  4423.   }
  4424.  
  4425.   if (firstchar != '\0')
  4426.     ptk_writeterminal(windid, firstchar);
  4427. }  /* ptk_printfterminal */
  4428.  
  4429. /*--------------------------------------------------------------------------*/
  4430.  
  4431. /*function:external*/
  4432. extern void ptk_clearterminal(C(Pint) windid)
  4433. PreANSI(Pint windid)
  4434. /*
  4435. ** \parambegin
  4436. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4437. ** \paramend
  4438. ** \blurb{This function empties the structure containing all the text
  4439. ** written to the TERMINAL window.}
  4440. */
  4441. {
  4442.   setwindow(windid);
  4443.   if (windptr != NULL)
  4444.   {
  4445.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4446.     {
  4447.       /* first clear out PHIGS structure */
  4448.       ptk_openstruct(windptr->term.textstid);
  4449.       pset_elem_ptr(0);
  4450.       pdel_elems_labels(ptk_stringtoint("label", "$tm_starttext"),
  4451.                       ptk_stringtoint("label", "$tm_endtext"));
  4452.       ptk_closestruct();
  4453.       predraw_all_structs(windptr->wsid, PFLAG_ALWAYS);
  4454.   
  4455.       /* now clear out data structure */
  4456.       windptr->term.curr_line = 0;
  4457.       windptr->term.curr_colm = windptr->term.columns;
  4458.       windptr->term.visline = 0;
  4459.   
  4460.       free(windptr->term.lastline);
  4461.       windptr->term.lastline = NULL;
  4462.       ptk_scrollterminal(windid, PPATH_UP, 1);
  4463.     }
  4464.   }
  4465. }  /* ptk_clearterminal */
  4466.  
  4467. /*--------------------------------------------------------------------------*/
  4468.  
  4469. /*function:external*/
  4470. extern void ptk_writeintterminal(C(Pint) windid, C(Pint) number)
  4471. PreANSI(Pint windid)
  4472. PreANSI(Pint number)
  4473. /*
  4474. ** \parambegin
  4475. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4476. ** \param{Pint}{number}{integer to write to window}{IN}
  4477. ** \paramend
  4478. ** \blurb{This function writes an integer to a TERMINAL window.}
  4479. */
  4480. {
  4481.   char intstr[81];
  4482.  
  4483.   sprintf(intstr, "%d", number);
  4484.   ptk_writeterminal(windid, intstr);
  4485. }  /* ptk_writeintterminal */
  4486.  
  4487. /*--------------------------------------------------------------------------*/
  4488.  
  4489. /*function:external*/
  4490. extern void ptk_writefloatterminal(C(Pint) windid, C(Pfloat) number)
  4491. PreANSI(Pint windid)
  4492. PreANSI(Pfloat number)
  4493. /*
  4494. ** \parambegin
  4495. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4496. ** \param{Pfloat}{number}{float number to write to window}{IN}
  4497. ** \paramend
  4498. ** \blurb{This function writes a floating point number to a TERMINAL window.}
  4499. */
  4500. {
  4501.   char floatstr[81];
  4502.  
  4503.   setwindow(windid);
  4504.   if (windptr != NULL)
  4505.   {
  4506.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4507.     {
  4508.       sprintf(floatstr, windptr->term.floatformat, number);
  4509.       ptk_writeterminal(windid, floatstr);
  4510.     }
  4511.   }
  4512. }  /* ptk_writefloatterminal */
  4513.  
  4514. /*--------------------------------------------------------------------------*/
  4515.  
  4516. /*function:external*/
  4517. extern void ptk_setterminalfloatformat(C(Pint) windid, C(char *) rformat)
  4518. PreANSI(Pint windid)
  4519. PreANSI(char *rformat)
  4520. /*
  4521. ** \parambegin
  4522. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4523. ** \param{char *}{rformat}{string giving C-type float number output style}{IN}
  4524. ** \paramend
  4525. ** \blurb{This function sets the format for writing floating-point numbers
  4526. ** to a TERMINAL window. The format used is the same syntax as in the
  4527. ** C language.}
  4528. */
  4529. {
  4530.   Pint rlen;
  4531.  
  4532.   setwindow(windid);
  4533.   if (windptr != NULL)
  4534.   {
  4535.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4536.     {
  4537.       rlen = strlen(rformat);
  4538.       if (rlen > ptkcfloatformat) 
  4539.         rlen = ptkcfloatformat; 
  4540.       strncpy(windptr->term.floatformat, rformat, (rlen + 1));
  4541.     }
  4542.   }
  4543. }  /* ptk_setterminalfloatformat */
  4544.  
  4545. /*--------------------------------------------------------------------------*/
  4546.  
  4547. /*function:external*/
  4548. extern void ptk_inqterminalfloatformat(C(Pint) windid, C(Pint) size, 
  4549.             C(Pint *) totalsize, C(char *) rformat, C(Pint *) err)
  4550. PreANSI(Pint windid)
  4551. PreANSI(Pint size)
  4552. PreANSI(Pint *totalsize)
  4553. PreANSI(char *rformat)
  4554. PreANSI(Pint *err)
  4555. /*
  4556. ** \parambegin
  4557. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4558. ** \param{Pint}{size}{size of buffer, in bytes, as allocated by application}{IN}
  4559. ** \param{Pint *}{totalsize}{actual size of buffer}{IN}
  4560. ** \param{char *}{rformat}{string giving C-type float number output style}{IN}
  4561. ** \param{Pint *}{err}{error indicator}{OUT}
  4562. ** \paramend
  4563. ** \blurb{This function may be used to obtain the floating-point used
  4564. ** for writing floating-point numbers to a TERMINAL window.
  4565. ** The error code = 1 if {\tt windid} doesn't exist and = 2 if it is
  4566. ** not a terminal window.}
  4567. */
  4568. {
  4569.   *err = 0;
  4570.   setwindow(windid);
  4571.   if (windptr != NULL)
  4572.   {
  4573.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4574.     {
  4575.       *totalsize = strlen(windptr->term.floatformat) + 1;
  4576.       if (size >= *totalsize)
  4577.       {
  4578.         strncpy(rformat, windptr->term.floatformat, *totalsize);
  4579.         rformat[*totalsize - 1] = '\0';
  4580.       }
  4581.     }
  4582.     else
  4583.       *err = 2;
  4584.   }
  4585.   else
  4586.     *err = 1;
  4587. }  /* ptk_inqterminalfloatformat */
  4588.  
  4589. /*--------------------------------------------------------------------------*/
  4590.  
  4591. /*function:external*/
  4592. extern void ptk_inqterminalstructid(C(Pint) windid, C(Pint *) termtextstid,
  4593.             C(Pint *) err)
  4594. PreANSI(Pint windid)
  4595. PreANSI(Pint *termtextstid)
  4596. PreANSI(Pint *err)
  4597. /*
  4598. ** \parambegin
  4599. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4600. ** \param{Pint *}{rformat}{string giving C-type real number output style}{IN}
  4601. ** \param{Pint *}{err}{error indicator}{OUT}
  4602. ** \paramend
  4603. ** \blurb{This function may be used to obtain the identifier of the
  4604. ** structure used to display the text written to a TERMINAL window.
  4605. ** The error code = 1 if {\tt windid} doesn't exist and = 2 if it is
  4606. ** not a terminal window.}
  4607. */
  4608. {
  4609.   *err = 0;
  4610.   setwindow(windid);
  4611.   if (windptr != NULL)
  4612.   {
  4613.     if (windptr->windowtype == PTKETERMINALWINDOW)
  4614.       *termtextstid = windptr->term.textstid;
  4615.     else
  4616.       *err = 2;
  4617.   }
  4618.   else
  4619.     *err = 1;
  4620. }  /* ptk_inqterminalstructid */
  4621.  
  4622. /*--------------------------------------------------------------------------*/
  4623. /*----------------------- Topology window functions ------------------------*/
  4624. /*--------------------------------------------------------------------------*/
  4625.  
  4626. /*function:external*/
  4627. extern void ptk_settopologyviewarea(C(Pint) windid, C(Plimit *) viewarea)
  4628. PreANSI(Pint windid)
  4629. PreANSI(Plimit *viewarea)
  4630. /*
  4631. ** \parambegin
  4632. ** \param{Pint}{windid}{window identifier}{IN}
  4633. ** \param{Plimit *}{viewarea}{area of topology to view}{IN}
  4634. ** \paramend 
  4635. ** \blurb{This function sets the viewing area of a topology diagram posted
  4636. ** to a TOPOLOGY window. The area is defined in the range [0, 1].}
  4637. */
  4638. {
  4639.   setwindow(windid);
  4640.   if (windptr != NULL)
  4641.   {
  4642.     if (windptr->windowtype == PTKETOPOLOGYWINDOW)
  4643.     {
  4644.       /* calculate aspect ratio of window */
  4645.       windptr->topviewarea = windptr->win = *viewarea;
  4646.       windptr->proj_ref_point.x = windptr->win.x_min + 
  4647.                        (windptr->win.x_max - windptr->win.x_min) / 2.0;
  4648.       windptr->proj_ref_point.y = windptr->win.y_min + 
  4649.                        (windptr->win.y_max - windptr->win.y_min) / 2.0;
  4650.       updateview();
  4651.     }
  4652.   }
  4653. }  /* ptk_settopologyviewarea */
  4654.  
  4655. /*--------------------------------------------------------------------------*/
  4656.  
  4657. /*function:external*/
  4658. extern void ptk_inqtopologyviewarea(C(Pint) windid, C(Plimit *) viewarea,
  4659.                                     C(Pint *) err)
  4660. PreANSI(Pint windid)
  4661. PreANSI(Plimit *viewarea)
  4662. PreANSI(Pint *err)
  4663. /*
  4664. ** \parambegin
  4665. ** \param{Pint}{windid}{window identifier}{IN}
  4666. ** \param{Plimit *}{viewarea}{area of topology to view}{OUT}
  4667. ** \param{Pint *}{err}{error indicator}{OUT}
  4668. ** \paramend 
  4669. ** \blurb{This function may be used to obtain the viewing area
  4670. ** of a topology diagram posted to a TOPOLOGY window.
  4671. ** The error code = 1 if {\tt windid} doesn't exist and = 2 if it is
  4672. ** not a topology window.}
  4673. */
  4674. {
  4675.   *err = 0;
  4676.   setwindow(windid);
  4677.   if (windptr != NULL)
  4678.   {
  4679.     if (windptr->windowtype == PTKETOPOLOGYWINDOW)
  4680.       *viewarea = windptr->topviewarea;
  4681.     else
  4682.       *err = 2;
  4683.   }
  4684.   else
  4685.     *err = 1;
  4686. }  /* ptk_inqtopologyviewarea */
  4687.  
  4688. /*--------------------------------------------------------------------------*/
  4689. /*----------------------- Content window functions -------------------------*/
  4690. /*--------------------------------------------------------------------------*/
  4691.  
  4692. /*function:external*/
  4693. extern void ptk_setcontentviewrange(C(Pint) windid, C(Pint) range1, 
  4694.                                     C(Pint) range2)
  4695. PreANSI(Pint windid)
  4696. PreANSI(Pint range1)
  4697. PreANSI(Pint range2)
  4698. /*
  4699. ** \parambegin
  4700. ** \param{Pint}{windid}{window identifier}{IN}
  4701. ** \param{Pint}{range1}{start element number}{IN}
  4702. ** \param{Pint}{range2}{end element number}{IN}
  4703. ** \paramend 
  4704. ** \blurb{This function sets the range of elements of a structure
  4705. ** content diagram to view in a CONTENT window.}
  4706. */
  4707. {
  4708.   Pfloat projht, projwt, winht, winwt, aspectratio, winaspectratio;
  4709.   Pfloat diff, elemspace, fudge;
  4710.   Pint numelems, first, last, viewelems;
  4711.  
  4712.   setwindow(windid);
  4713.   if (windptr != NULL)
  4714.   {
  4715.     if (windptr->windowtype == PTKECONTENTWINDOW)
  4716.     {
  4717.       /* check range is valid */
  4718.       first = range1;
  4719.       last = range2;
  4720.       if (range1 < 0)
  4721.         first = windptr->range1;
  4722.       if ((range2 > windptr->range2) || (range2 == 0))
  4723.         last = windptr->range2;
  4724.       if (last < first)
  4725.         last = first;
  4726.  
  4727.       windptr->viewrange1 = first;
  4728.       windptr->viewrange2 = last;
  4729.       /* calculate window given element range to view */
  4730.       numelems = windptr->range2 - windptr->range1 + 2;
  4731.      
  4732.       if (numelems < 10) 
  4733.         elemspace = 0.1;
  4734.       else
  4735.         elemspace = 1.0 / (Pfloat)numelems;
  4736.       fudge = 0.01/(Pfloat)numelems;
  4737.       windptr->win.y_max = 1.0 - ((Pfloat)(first - windptr->range1 + 1) * 
  4738.                                     elemspace);
  4739.       windptr->win.y_min = 1.0 - ((Pfloat)(last - windptr->range1 + 2) * 
  4740.                                     elemspace) - fudge;
  4741.       windptr->win.x_min = 0.0;
  4742.       viewelems = last - first + 1;
  4743.       if (viewelems < 10)
  4744.         viewelems = 10;
  4745.       if (numelems < 10) 
  4746.         windptr->win.x_max = 1.0;
  4747.       else
  4748.         windptr->win.x_max = (Pfloat)viewelems / (Pfloat)numelems;
  4749.       /* calculate aspect ratio of window */
  4750.       projht = windptr->win.y_max - windptr->win.y_min;
  4751.       projwt = windptr->win.x_max - windptr->win.x_min;
  4752.       aspectratio = projht / projwt;
  4753.   
  4754.       /* adjust view area to have same aspect ratio as window */
  4755.       windptr->viewbox = windptr->proj_vp = windptr->viewlims;
  4756.       winht = windptr->proj_vp.y_max - windptr->proj_vp.y_min;
  4757.       winwt = windptr->proj_vp.x_max - windptr->proj_vp.x_min;
  4758.       winaspectratio = winht / winwt;
  4759.       
  4760.       if (aspectratio > winaspectratio)
  4761.       {
  4762.         /* decrease x */
  4763.         diff = (winwt - ((1.0 / aspectratio) * winht));
  4764.         windptr->proj_vp.x_max -= diff;
  4765.       }
  4766.       else
  4767.       if (aspectratio < winaspectratio)
  4768.       {
  4769.         /* decrease y */
  4770.         diff = (winht - (aspectratio * winwt));
  4771.         windptr->proj_vp.y_min += diff;
  4772.       }       
  4773.  
  4774.       windptr->proj_ref_point = ptk_point3(
  4775.         (windptr->win.x_max - windptr->win.x_min) / 2.0, 
  4776.         (windptr->win.y_min +
  4777.          (windptr->win.y_max - windptr->win.y_min) / 2.0), 2.0);
  4778.  
  4779.       updateview();
  4780.     }
  4781.   }
  4782. }  /* ptk_setcontentviewrange */
  4783.  
  4784. /*--------------------------------------------------------------------------*/
  4785.  
  4786. /*function:external*/
  4787. extern void ptk_inqcontentviewrange(C(Pint) windid, C(Pint *) range1, 
  4788.                                 C(Pint *) range2, C(Pint *) err)
  4789. PreANSI(Pint windid)
  4790. PreANSI(Pint *range1)
  4791. PreANSI(Pint *range2)
  4792. PreANSI(Pint *err)
  4793. /*
  4794. ** \parambegin
  4795. ** \param{Pint}{windid}{terminal window identifier}{IN}
  4796. ** \param{Pint}{range1}{element number}{IN}
  4797. ** \param{Pint}{range2}{element number}{IN}
  4798. ** \param{Pint *}{err}{error indicator}{OUT}
  4799. ** \paramend
  4800. ** \blurb{This function may be used to obtain the viewing range of
  4801. ** a structure content diagram which is posted to a CONTENT window.
  4802. ** The error code = 1 if {\tt windid} doesn't exist and = 2 if it is
  4803. ** not a content window.}
  4804. */
  4805. {
  4806.   *err = 0;
  4807.   setwindow(windid);
  4808.   if (windptr != NULL)
  4809.   {
  4810.     if (windptr->windowtype == PTKECONTENTWINDOW)
  4811.     {
  4812.       *range1 = windptr->viewrange1;
  4813.       *range2 = windptr->viewrange2;
  4814.     }
  4815.     else
  4816.       *err = 2;
  4817.   }
  4818.   else
  4819.     *err = 1;
  4820. }  /* ptk_inqcontentviewrange */
  4821.  
  4822. /*--------------------------------------------------------------------------*/
  4823. /*----------------------- Window type functions ----------------------------*/
  4824. /*--------------------------------------------------------------------------*/
  4825.  
  4826. /*function:external*/
  4827. extern void ptk_setwindowtype(C(Pint) windid, C(ptkewindowtype) windtype)
  4828. PreANSI(Pint windid)
  4829. PreANSI(ptkewindowtype windtype)
  4830. /*
  4831. ** \parambegin
  4832. ** \param{Pint}{windid}{window identifier}{IN}
  4833. ** \param{ptkewindowtype}{windtype}{window type}{IN}
  4834. ** \paramend 
  4835. ** \blurb{This function sets the type of a window to one of
  4836. ** STRUCT, TOPOLOGY, CONTENT and TERMINAL. The default window type is
  4837. ** STRUCT. All items are unposted from the window before the type
  4838. ** is set.}
  4839. */
  4840. {
  4841.   char stname[20];
  4842.  
  4843.   setwindow(windid);
  4844.   if (windptr != NULL)
  4845.   {
  4846.     windptr->windowtype = windtype;
  4847.     ptk_unpostallfromwindow(windid);
  4848.     switch (windtype)
  4849.     {
  4850.     case PTKESTRUCTWINDOW:
  4851.       /* change icon */
  4852.       ptk_openstruct(windptr->iconstid);
  4853.       pset_elem_ptr(0);
  4854.       pdel_elems_labels(ptk_stringtoint("label", "begin-icon-pic"), 
  4855.                       ptk_stringtoint("label", "end-icon"));  
  4856.       ptk_seteditmode(PEDIT_INSERT);
  4857.       do_structicon();
  4858.       ptk_unseteditmode();
  4859.       ptk_closestruct(); 
  4860.       break;
  4861.   
  4862.     case PTKETERMINALWINDOW:
  4863.       /* create a text structure */
  4864.       sprintf(stname, "ptk$term%d", windid);
  4865.       windptr->term.textstid = ptk_stringtoint("structureid", stname);
  4866.   
  4867.       /* post to window */
  4868.       ptk_openstruct(windptr->windowstid);
  4869.       ptk_seteditmode(PEDIT_INSERT);
  4870.       pset_elem_ptr(0);
  4871.       pset_elem_ptr_label(ptk_stringtoint("label", "begin-window"));
  4872.       pexec_struct(windptr->term.textstid);    
  4873.       ptk_unseteditmode();
  4874.       ptk_closestruct();
  4875.   
  4876.       /* initialise */
  4877.       windptr->term.curr_line = 0;
  4878.       windptr->term.visline = 0;
  4879.       strncpy(windptr->term.floatformat, "%.5e", 5);
  4880.       windptr->term.lastline = NULL;
  4881.       ptk_setterminaldata(windid, 20, 1, 1);
  4882.       windptr->term.curr_colm = windptr->term.columns;
  4883.       /* initialise view */
  4884.       windptr->cameraswitch = PTKECAMERAOFF;
  4885.       initialiseterminal();
  4886.       ptk_scrollterminal(windid, PPATH_UP, 1);
  4887.  
  4888.       /* change icon */
  4889.       ptk_openstruct(windptr->iconstid);
  4890.       pset_elem_ptr(0);
  4891.       pdel_elems_labels(ptk_stringtoint("label", "begin-icon-pic"), 
  4892.                       ptk_stringtoint("label", "end-icon"));  
  4893.       ptk_seteditmode(PEDIT_INSERT);
  4894.       do_terminalicon();
  4895.       ptk_unseteditmode();
  4896.       ptk_closestruct(); 
  4897.       break;
  4898.   
  4899.     case PTKETOPOLOGYWINDOW:
  4900.       windptr->proj_vp = ptk_limit3(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);  
  4901.       /* default viewing variables */
  4902.       windptr->proj_type = PTYPE_PARAL;
  4903.       windptr->vrp = ptk_point3(0.0, 0.0, 0.0);
  4904.       windptr->proj_ref_point = ptk_point3(0.5, 0.5, 2.0);
  4905.       windptr->vpn = ptk_point3(0.0, 0.0, 1.0);
  4906.       windptr->vup = ptk_point3(0.0, 1.0, 0.0);
  4907.       windptr->topviewarea = windptr->win = ptk_limit(0.0, 1.0, 0.0, 1.0);
  4908.       windptr->viewplane = windptr->frontplane = 1.0;
  4909.       windptr->backplane = 0.0;
  4910.   
  4911.       /* other window defaults */
  4912.       windptr->cameraswitch = PTKECAMERAOFF;
  4913.       updateview();
  4914.  
  4915.       /* change icon */
  4916.       ptk_openstruct(windptr->iconstid);
  4917.       pset_elem_ptr(0);
  4918.       pdel_elems_labels(ptk_stringtoint("label", "begin-icon-pic"), 
  4919.                       ptk_stringtoint("label", "end-icon"));  
  4920.       ptk_seteditmode(PEDIT_INSERT);
  4921.       do_topologyicon();
  4922.       ptk_unseteditmode();
  4923.       ptk_closestruct(); 
  4924.       break;
  4925.   
  4926.     case PTKECONTENTWINDOW:
  4927.       windptr->cliplimit = windptr->viewlims;
  4928.       /* default viewing variables */
  4929.       windptr->proj_type = PTYPE_PARAL;
  4930.       windptr->vrp = ptk_point3(0.0, 0.0, 0.0);
  4931.       windptr->proj_ref_point = ptk_point3(0.5, 0.5, 2.0);
  4932.       windptr->vpn = ptk_point3(0.0, 0.0, 1.0);
  4933.       windptr->vup = ptk_point3(0.0, 1.0, 0.0);
  4934.       windptr->win = ptk_limit(0.0, 1.0, 0.0, 1.0);
  4935.       windptr->viewplane = windptr->frontplane = 1.0;
  4936.       windptr->backplane = 0.0;
  4937.       
  4938.       /* other window defaults */
  4939.       windptr->cameraswitch = PTKECAMERAOFF;
  4940.       updateview();
  4941.  
  4942.       /* change icon */
  4943.       ptk_openstruct(windptr->iconstid);
  4944.       pset_elem_ptr(0);
  4945.       pdel_elems_labels(ptk_stringtoint("label", "begin-icon-pic"), 
  4946.                       ptk_stringtoint("label", "end-icon"));  
  4947.       ptk_seteditmode(PEDIT_INSERT);
  4948.       do_contenticon();
  4949.       ptk_unseteditmode();
  4950.       ptk_closestruct(); 
  4951.       break;
  4952.     }
  4953.   }
  4954. }  /* ptk_setwindowtype */
  4955.  
  4956. /*--------------------------------------------------------------------------*/
  4957.  
  4958. /* end of wind.c */
  4959.  
  4960.